From fbfc305174af29d630846194586211dbfd9f1373 Mon Sep 17 00:00:00 2001 From: Owen Taylor Date: Sat, 30 Jun 2001 16:08:25 +0000 Subject: [PATCH] Allow %NULL for style to mean "revert to default style" Tue Jun 26 19:39:03 2001 Owen Taylor * 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 * 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 --- ChangeLog | 85 ++ ChangeLog.pre-2-0 | 85 ++ ChangeLog.pre-2-10 | 85 ++ ChangeLog.pre-2-2 | 85 ++ ChangeLog.pre-2-4 | 85 ++ ChangeLog.pre-2-6 | 85 ++ ChangeLog.pre-2-8 | 85 ++ docs/Changes-2.0.txt | 5 + docs/reference/gtk/tmpl/gtkenums.sgml | 1 + docs/reference/gtk/tmpl/gtkrc.sgml | 38 +- gdk/x11/gdkevents-x11.c | 4 +- gtk/gtkcolorsel.c | 13 +- gtk/gtkentry.c | 8 +- gtk/gtkenums.h | 1 + gtk/gtkiconfactory.c | 26 +- gtk/gtkmenu.c | 2 +- gtk/gtkmenubar.c | 5 +- gtk/gtkrc.c | 1116 +++++++++++++++++-------- gtk/gtkrc.h | 47 +- gtk/gtksettings.c | 39 +- gtk/gtksettings.h | 11 +- gtk/gtktextview.c | 7 +- gtk/gtktoolbar.c | 20 +- gtk/gtkwidget.c | 184 +--- gtk/gtkwidget.h | 12 +- gtk/gtkwindow.c | 24 +- tests/testgtk.c | 24 +- tests/testgtkrc | 2 - 28 files changed, 1529 insertions(+), 655 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 + + * 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 + + * 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 * 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 + + * 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 + + * 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 * 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 + + * 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 + + * 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 * 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 + + * 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 + + * 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 * 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 + + * 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 + + * 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 * 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 + + * 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 + + * 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 * 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 + + * 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 + + * 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 * 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. -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.) -@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: @@ -686,42 +678,30 @@ Parse resource information directly from a string. -If the modification time on any previously read file -has changed, discard all style information -and then reread all previously read RC files. -@Returns: %TRUE if the files were reread. +@Returns: -Adds a file to the list of files to be parsed at the -end of gtk_init(). -@filename: the pathname to the file. +@filename: -Retrieves the current list of RC files that will be parsed -at the end of gtk_init() -@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: -Sets the list of files that GTK+ will read at the -end of gtk_init() -@filenames: A %NULL terminated list of filenames. +@filenames: @@ -773,11 +753,9 @@ otherwise %NULL. -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. +@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 @@ -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 , 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 , 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) { - gint length; - gchar *locale; - gchar *p; + memcpy (retval, "iso", 4); + wp = retval + 3; + } + else + wp = retval; -#ifdef G_OS_WIN32 - locale = g_win32_getlocale (); -#else - locale = setlocale (LC_CTYPE, NULL); -#endif - initialized = TRUE; + 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]; - pixmap_path[0] = NULL; - module_path[0] = NULL; - gtk_rc_append_default_module_path(); + *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); - gtk_rc_add_initial_default_files (); + context->pixmap_path[0] = NULL; - if (strcmp (locale, "C") && strcmp (locale, "POSIX")) + 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)) { - /* 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); - - p = strchr (normalized_locale, '_'); - if (p) - { - locale_suffixes[n_locale_suffixes++] = g_strndup (normalized_locale, length); - length = p - normalized_locale; - } - - locale_suffixes[n_locale_suffixes++] = g_strndup (normalized_locale, length); - - g_free (normalized_locale); + 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) + { + 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 (); +#else + locale = setlocale (LC_CTYPE, NULL); +#endif + + 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; + + 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); + + p = strchr (normalized_locale, '_'); + if (p) + { + locale_suffixes[n_locale_suffixes++] = g_strndup (normalized_locale, length); + 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; } -gboolean -gtk_rc_reparse_all (void) +/* 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_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) - { - 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; - } + g_return_val_if_fail (GTK_IS_SETTINGS (settings), FALSE); - if (mtime_modified) - { - gtk_rc_clear_styles(); + context = gtk_rc_context_get (settings); - tmp_list = rc_files; + if (!force_load) + { + /* 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) { rc_file = tmp_list->data; - if (rc_file->reload) - gtk_rc_parse_file (rc_file->name, FALSE); + + if (!lstat (rc_file->name, &statbuf) && + (statbuf.st_mtime > rc_file->mtime)) + { + mtime_modified = TRUE; + break; + } tmp_list = tmp_list->next; } } + + if (force_load || mtime_modified) + { + 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 = old_files; + while (tmp_list) + { + rc_file = tmp_list->data; + if (rc_file->reload) + 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, "") == 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; + g_scanner_warn (scanner, "Invalid color constant '%s'", + scanner->value.v_string); + return G_TOKEN_STRING; } - 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; - } - 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); + source = gtk_icon_source_new (); + + 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 -#include #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); +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); -GtkStyle* gtk_rc_get_style (GtkWidget *widget); - 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); - - default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_saved_default_style); - if (!default_style) + if (style) { - gtk_style_ref (widget->style); - gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_saved_default_style, widget->style); - } + gboolean initial_emission; - gtk_widget_set_style_internal (widget, style, initial_emission); + 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 + { + if (GTK_WIDGET_USER_STYLE (widget)) + gtk_widget_reset_rc_style (widget); + } } /** @@ -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 */ + if (!new_style) + new_style = gtk_widget_get_default_style (); - 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); - - 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 #include #include +#include #include #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 @@ -9882,28 +9882,6 @@ create_idle_test (void) * rc file test */ -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) { @@ -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