X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkradiobutton.c;h=2da7a73541b253a3f3dff72bb5c1a37afb20fbef;hb=e53efb120ae5251b44d089ed6fe35f411a674dd4;hp=e41f04233f48ec0125fc064e0c5758d6c0a726b8;hpb=4e2b60ac4d32c5bef5b192a12a59f8c2a3124f81;p=~andy%2Fgtk diff --git a/gtk/gtkradiobutton.c b/gtk/gtkradiobutton.c index e41f04233..2da7a7354 100644 --- a/gtk/gtkradiobutton.c +++ b/gtk/gtkradiobutton.c @@ -24,134 +24,153 @@ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ +#include "config.h" #include "gtklabel.h" +#include "gtkmarshalers.h" #include "gtkradiobutton.h" -#include "gtksignal.h" +#include "gtkprivate.h" +#include "gtkintl.h" +#include "gtkalias.h" enum { - ARG_0, - ARG_GROUP + PROP_0, + PROP_GROUP }; -static void gtk_radio_button_class_init (GtkRadioButtonClass *klass); -static void gtk_radio_button_init (GtkRadioButton *radio_button); -static void gtk_radio_button_destroy (GtkObject *object); -static void gtk_radio_button_clicked (GtkButton *button); -static void gtk_radio_button_draw_indicator (GtkCheckButton *check_button, - GdkRectangle *area); -static void gtk_radio_button_set_arg (GtkObject *object, - GtkArg *arg, - guint arg_id); -static void gtk_radio_button_get_arg (GtkObject *object, - GtkArg *arg, - guint arg_id); +static void gtk_radio_button_destroy (GtkObject *object); +static gboolean gtk_radio_button_focus (GtkWidget *widget, + GtkDirectionType direction); +static void gtk_radio_button_clicked (GtkButton *button); +static void gtk_radio_button_draw_indicator (GtkCheckButton *check_button, + GdkRectangle *area); +static void gtk_radio_button_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void gtk_radio_button_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); +G_DEFINE_TYPE (GtkRadioButton, gtk_radio_button, GTK_TYPE_CHECK_BUTTON) -static GtkCheckButtonClass *parent_class = NULL; - - -GtkType -gtk_radio_button_get_type (void) -{ - static GtkType radio_button_type = 0; - - if (!radio_button_type) - { - static const GtkTypeInfo radio_button_info = - { - "GtkRadioButton", - sizeof (GtkRadioButton), - sizeof (GtkRadioButtonClass), - (GtkClassInitFunc) gtk_radio_button_class_init, - (GtkObjectInitFunc) gtk_radio_button_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - radio_button_type = gtk_type_unique (gtk_check_button_get_type (), &radio_button_info); - } - - return radio_button_type; -} +static guint group_changed_signal = 0; static void gtk_radio_button_class_init (GtkRadioButtonClass *class) { + GObjectClass *gobject_class; GtkObjectClass *object_class; GtkButtonClass *button_class; GtkCheckButtonClass *check_button_class; + GtkWidgetClass *widget_class; + gobject_class = G_OBJECT_CLASS (class); object_class = (GtkObjectClass*) class; + widget_class = (GtkWidgetClass*) class; button_class = (GtkButtonClass*) class; check_button_class = (GtkCheckButtonClass*) class; - parent_class = gtk_type_class (gtk_check_button_get_type ()); - - gtk_object_add_arg_type ("GtkRadioButton::group", GTK_TYPE_RADIO_BUTTON, GTK_ARG_WRITABLE, ARG_GROUP); + gobject_class->set_property = gtk_radio_button_set_property; + gobject_class->get_property = gtk_radio_button_get_property; - object_class->set_arg = gtk_radio_button_set_arg; - object_class->get_arg = gtk_radio_button_get_arg; + g_object_class_install_property (gobject_class, + PROP_GROUP, + g_param_spec_object ("group", + P_("Group"), + P_("The radio button whose group this widget belongs to."), + GTK_TYPE_RADIO_BUTTON, + GTK_PARAM_WRITABLE)); object_class->destroy = gtk_radio_button_destroy; + widget_class->focus = gtk_radio_button_focus; + button_class->clicked = gtk_radio_button_clicked; check_button_class->draw_indicator = gtk_radio_button_draw_indicator; + + class->group_changed = NULL; + + /** + * GtkRadioButton::group-changed: + * @style: the object which received the signal + * + * Emitted when the group of radio buttons that a radio button belongs + * to changes. This is emitted when a radio button switches from + * being alone to being part of a group of 2 or more buttons, or + * vice-versa, and when a button is moved from one group of 2 or + * more buttons to a different one, but not when the composition + * of the group that a button belongs to changes. + * + * Since: 2.4 + */ + group_changed_signal = g_signal_new (I_("group-changed"), + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GtkRadioButtonClass, group_changed), + NULL, NULL, + _gtk_marshal_VOID__VOID, + G_TYPE_NONE, 0); } static void gtk_radio_button_init (GtkRadioButton *radio_button) { GTK_WIDGET_SET_FLAGS (radio_button, GTK_NO_WINDOW); - GTK_WIDGET_UNSET_FLAGS (radio_button, GTK_RECEIVES_DEFAULT); + gtk_widget_set_receives_default (GTK_WIDGET (radio_button), FALSE); GTK_TOGGLE_BUTTON (radio_button)->active = TRUE; + GTK_BUTTON (radio_button)->depress_on_activate = FALSE; + radio_button->group = g_slist_prepend (NULL, radio_button); + _gtk_button_set_depressed (GTK_BUTTON (radio_button), TRUE); gtk_widget_set_state (GTK_WIDGET (radio_button), GTK_STATE_ACTIVE); } static void -gtk_radio_button_set_arg (GtkObject *object, - GtkArg *arg, - guint arg_id) +gtk_radio_button_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) { GtkRadioButton *radio_button; radio_button = GTK_RADIO_BUTTON (object); - switch (arg_id) + switch (prop_id) { GSList *slist; + GtkRadioButton *button; + + case PROP_GROUP: + button = g_value_get_object (value); - case ARG_GROUP: - if (GTK_VALUE_OBJECT (*arg)) - slist = gtk_radio_button_get_group ((GtkRadioButton*) GTK_VALUE_OBJECT (*arg)); + if (button) + slist = gtk_radio_button_get_group (button); else slist = NULL; gtk_radio_button_set_group (radio_button, slist); break; default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void -gtk_radio_button_get_arg (GtkObject *object, - GtkArg *arg, - guint arg_id) +gtk_radio_button_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) { - GtkRadioButton *radio_button; - - radio_button = GTK_RADIO_BUTTON (object); - - switch (arg_id) + switch (prop_id) { default: - arg->type = GTK_TYPE_INVALID; + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } @@ -160,15 +179,21 @@ void gtk_radio_button_set_group (GtkRadioButton *radio_button, GSList *group) { + GtkWidget *old_group_singleton = NULL; + GtkWidget *new_group_singleton = NULL; + g_return_if_fail (GTK_IS_RADIO_BUTTON (radio_button)); g_return_if_fail (!g_slist_find (group, radio_button)); if (radio_button->group) { GSList *slist; - + radio_button->group = g_slist_remove (radio_button->group, radio_button); + if (radio_button->group && !radio_button->group->next) + old_group_singleton = g_object_ref (radio_button->group->data); + for (slist = radio_button->group; slist; slist = slist->next) { GtkRadioButton *tmp_button; @@ -179,6 +204,9 @@ gtk_radio_button_set_group (GtkRadioButton *radio_button, } } + if (group && !group->next) + new_group_singleton = g_object_ref (group->data); + radio_button->group = g_slist_prepend (group, radio_button); if (group) @@ -195,7 +223,24 @@ gtk_radio_button_set_group (GtkRadioButton *radio_button, } } + g_object_ref (radio_button); + + g_object_notify (G_OBJECT (radio_button), "group"); + g_signal_emit (radio_button, group_changed_signal, 0); + if (old_group_singleton) + { + g_signal_emit (old_group_singleton, group_changed_signal, 0); + g_object_unref (old_group_singleton); + } + if (new_group_singleton) + { + g_signal_emit (new_group_singleton, group_changed_signal, 0); + g_object_unref (new_group_singleton); + } + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_button), group == NULL); + + g_object_unref (radio_button); } GtkWidget* @@ -203,7 +248,7 @@ gtk_radio_button_new (GSList *group) { GtkRadioButton *radio_button; - radio_button = gtk_type_new (gtk_radio_button_get_type ()); + radio_button = g_object_new (GTK_TYPE_RADIO_BUTTON, NULL); if (group) gtk_radio_button_set_group (radio_button, group); @@ -216,14 +261,11 @@ gtk_radio_button_new_with_label (GSList *group, const gchar *label) { GtkWidget *radio_button; - GtkWidget *label_widget; - radio_button = gtk_radio_button_new (group); - label_widget = gtk_label_new (label); - gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5); + radio_button = g_object_new (GTK_TYPE_RADIO_BUTTON, "label", label, NULL) ; - gtk_container_add (GTK_CONTAINER (radio_button), label_widget); - gtk_widget_show (label_widget); + if (group) + gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio_button), group); return radio_button; } @@ -236,50 +278,51 @@ gtk_radio_button_new_with_label (GSList *group, * mnemonic character * @returns: a new #GtkRadioButton * - * Creates a new #GtkRadioButton containing a label. The label - * will be created using gtk_label_new_with_mnemonic(), so underscores - * in @label indicate the mnemonic for the button. + * Creates a new #GtkRadioButton containing a label, adding it to the same + * group as @group. The label will be created using + * gtk_label_new_with_mnemonic(), so underscores in @label indicate the + * mnemonic for the button. **/ GtkWidget* gtk_radio_button_new_with_mnemonic (GSList *group, const gchar *label) { GtkWidget *radio_button; - GtkWidget *label_widget; - radio_button = gtk_radio_button_new (group); - label_widget = gtk_label_new_with_mnemonic (label); - gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5); + radio_button = g_object_new (GTK_TYPE_RADIO_BUTTON, + "label", label, + "use-underline", TRUE, + NULL); - gtk_container_add (GTK_CONTAINER (radio_button), label_widget); - gtk_widget_show (label_widget); + if (group) + gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio_button), group); return radio_button; } GtkWidget* -gtk_radio_button_new_from_widget (GtkRadioButton *group) +gtk_radio_button_new_from_widget (GtkRadioButton *radio_group_member) { GSList *l = NULL; - if (group) - l = gtk_radio_button_get_group (group); + if (radio_group_member) + l = gtk_radio_button_get_group (radio_group_member); return gtk_radio_button_new (l); } GtkWidget* -gtk_radio_button_new_with_label_from_widget (GtkRadioButton *group, +gtk_radio_button_new_with_label_from_widget (GtkRadioButton *radio_group_member, const gchar *label) { GSList *l = NULL; - if (group) - l = gtk_radio_button_get_group (group); + if (radio_group_member) + l = gtk_radio_button_get_group (radio_group_member); return gtk_radio_button_new_with_label (l, label); } /** * gtk_radio_button_new_with_mnemonic_from_widget: - * @group: widget to get radio group from + * @radio_group_member: (allow-none): widget to get radio group from or %NULL * @label: the text of the button, with an underscore in front of the * mnemonic character * @returns: a new #GtkRadioButton @@ -289,15 +332,27 @@ gtk_radio_button_new_with_label_from_widget (GtkRadioButton *group, * in @label indicate the mnemonic for the button. **/ GtkWidget* -gtk_radio_button_new_with_mnemonic_from_widget (GtkRadioButton *group, +gtk_radio_button_new_with_mnemonic_from_widget (GtkRadioButton *radio_group_member, const gchar *label) { GSList *l = NULL; - if (group) - l = gtk_radio_button_get_group (group); + if (radio_group_member) + l = gtk_radio_button_get_group (radio_group_member); return gtk_radio_button_new_with_mnemonic (l, label); } + +/** + * gtk_radio_button_get_group: + * @radio_button: a #GtkRadioButton. + * + * Retrieves the group assigned to a radio button. + * + * Return value: (element-type GtkRadioButton) (transfer none): a linked list + * containing all the radio buttons in the same group + * as @radio_button. The returned list is owned by the radio button + * and must not be modified or freed. + */ GSList* gtk_radio_button_get_group (GtkRadioButton *radio_button) { @@ -310,15 +365,20 @@ gtk_radio_button_get_group (GtkRadioButton *radio_button) static void gtk_radio_button_destroy (GtkObject *object) { + GtkWidget *old_group_singleton = NULL; GtkRadioButton *radio_button; GtkRadioButton *tmp_button; GSList *tmp_list; - - g_return_if_fail (GTK_IS_RADIO_BUTTON (object)); - + gboolean was_in_group; + radio_button = GTK_RADIO_BUTTON (object); + was_in_group = radio_button->group && radio_button->group->next; + radio_button->group = g_slist_remove (radio_button->group, radio_button); + if (radio_button->group && !radio_button->group->next) + old_group_singleton = radio_button->group->data; + tmp_list = radio_button->group; while (tmp_list) @@ -329,8 +389,196 @@ gtk_radio_button_destroy (GtkObject *object) tmp_button->group = radio_button->group; } - if (GTK_OBJECT_CLASS (parent_class)->destroy) - (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); + /* this button is no longer in the group */ + radio_button->group = NULL; + + if (old_group_singleton) + g_signal_emit (old_group_singleton, group_changed_signal, 0); + if (was_in_group) + g_signal_emit (radio_button, group_changed_signal, 0); + + GTK_OBJECT_CLASS (gtk_radio_button_parent_class)->destroy (object); +} + +static void +get_coordinates (GtkWidget *widget, + GtkWidget *reference, + gint *x, + gint *y) +{ + *x = widget->allocation.x + widget->allocation.width / 2; + *y = widget->allocation.y + widget->allocation.height / 2; + + gtk_widget_translate_coordinates (widget, reference, *x, *y, x, y); +} + +static gint +left_right_compare (gconstpointer a, + gconstpointer b, + gpointer data) +{ + gint x1, y1, x2, y2; + + get_coordinates ((GtkWidget *)a, data, &x1, &y1); + get_coordinates ((GtkWidget *)b, data, &x2, &y2); + + if (y1 == y2) + return (x1 < x2) ? -1 : ((x1 == x2) ? 0 : 1); + else + return (y1 < y2) ? -1 : 1; +} + +static gint +up_down_compare (gconstpointer a, + gconstpointer b, + gpointer data) +{ + gint x1, y1, x2, y2; + + get_coordinates ((GtkWidget *)a, data, &x1, &y1); + get_coordinates ((GtkWidget *)b, data, &x2, &y2); + + if (x1 == x2) + return (y1 < y2) ? -1 : ((y1 == y2) ? 0 : 1); + else + return (x1 < x2) ? -1 : 1; +} + +static gboolean +gtk_radio_button_focus (GtkWidget *widget, + GtkDirectionType direction) +{ + GtkRadioButton *radio_button = GTK_RADIO_BUTTON (widget); + GSList *tmp_slist; + + /* Radio buttons with draw_indicator unset focus "normally", since + * they look like buttons to the user. + */ + if (!GTK_TOGGLE_BUTTON (widget)->draw_indicator) + return GTK_WIDGET_CLASS (gtk_radio_button_parent_class)->focus (widget, direction); + + if (gtk_widget_is_focus (widget)) + { + GtkSettings *settings = gtk_widget_get_settings (widget); + GSList *focus_list, *tmp_list; + GtkWidget *toplevel = gtk_widget_get_toplevel (widget); + GtkWidget *new_focus = NULL; + gboolean cursor_only; + gboolean wrap_around; + + switch (direction) + { + case GTK_DIR_LEFT: + case GTK_DIR_RIGHT: + focus_list = g_slist_copy (radio_button->group); + focus_list = g_slist_sort_with_data (focus_list, left_right_compare, toplevel); + break; + case GTK_DIR_UP: + case GTK_DIR_DOWN: + focus_list = g_slist_copy (radio_button->group); + focus_list = g_slist_sort_with_data (focus_list, up_down_compare, toplevel); + break; + case GTK_DIR_TAB_FORWARD: + case GTK_DIR_TAB_BACKWARD: + /* fall through */ + default: + return FALSE; + } + + if (direction == GTK_DIR_LEFT || direction == GTK_DIR_UP) + focus_list = g_slist_reverse (focus_list); + + tmp_list = g_slist_find (focus_list, widget); + + if (tmp_list) + { + tmp_list = tmp_list->next; + + while (tmp_list) + { + GtkWidget *child = tmp_list->data; + + if (gtk_widget_get_mapped (child) && gtk_widget_is_sensitive (child)) + { + new_focus = child; + break; + } + + tmp_list = tmp_list->next; + } + } + + g_object_get (settings, + "gtk-keynav-cursor-only", &cursor_only, + "gtk-keynav-wrap-around", &wrap_around, + NULL); + + if (!new_focus) + { + if (cursor_only) + { + g_slist_free (focus_list); + return FALSE; + } + + if (!wrap_around) + { + g_slist_free (focus_list); + gtk_widget_error_bell (widget); + return TRUE; + } + + tmp_list = focus_list; + + while (tmp_list) + { + GtkWidget *child = tmp_list->data; + + if (gtk_widget_get_mapped (child) && gtk_widget_is_sensitive (child)) + { + new_focus = child; + break; + } + + tmp_list = tmp_list->next; + } + } + + g_slist_free (focus_list); + + if (new_focus) + { + gtk_widget_grab_focus (new_focus); + + if (!cursor_only) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (new_focus), TRUE); + } + + return TRUE; + } + else + { + GtkRadioButton *selected_button = NULL; + + /* We accept the focus if, we don't have the focus and + * - we are the currently active button in the group + * - there is no currently active radio button. + */ + + tmp_slist = radio_button->group; + while (tmp_slist) + { + if (GTK_TOGGLE_BUTTON (tmp_slist->data)->active) + selected_button = tmp_slist->data; + tmp_slist = tmp_slist->next; + } + + if (selected_button && selected_button != radio_button) + return FALSE; + + gtk_widget_grab_focus (widget); + return TRUE; + } } static void @@ -342,14 +590,13 @@ gtk_radio_button_clicked (GtkButton *button) GtkStateType new_state; GSList *tmp_list; gint toggled; - - g_return_if_fail (GTK_IS_RADIO_BUTTON (button)); + gboolean depressed; radio_button = GTK_RADIO_BUTTON (button); toggle_button = GTK_TOGGLE_BUTTON (button); toggled = FALSE; - gtk_widget_ref (GTK_WIDGET (button)); + g_object_ref (GTK_WIDGET (button)); if (toggle_button->active) { @@ -382,7 +629,7 @@ gtk_radio_button_clicked (GtkButton *button) { toggled = TRUE; toggle_button->active = !toggle_button->active; - + tmp_list = radio_button->group; while (tmp_list) { @@ -399,15 +646,28 @@ gtk_radio_button_clicked (GtkButton *button) new_state = (button->in_button ? GTK_STATE_PRELIGHT : GTK_STATE_ACTIVE); } + if (toggle_button->inconsistent) + depressed = FALSE; + else if (button->in_button && button->button_down) + depressed = !toggle_button->active; + else + depressed = toggle_button->active; + if (GTK_WIDGET_STATE (button) != new_state) gtk_widget_set_state (GTK_WIDGET (button), new_state); if (toggled) - gtk_toggle_button_toggled (toggle_button); + { + gtk_toggle_button_toggled (toggle_button); + + g_object_notify (G_OBJECT (toggle_button), "active"); + } + + _gtk_button_set_depressed (button, depressed); gtk_widget_queue_draw (GTK_WIDGET (button)); - gtk_widget_unref (GTK_WIDGET (button)); + g_object_unref (button); } static void @@ -415,62 +675,84 @@ gtk_radio_button_draw_indicator (GtkCheckButton *check_button, GdkRectangle *area) { GtkWidget *widget; + GtkWidget *child; GtkButton *button; GtkToggleButton *toggle_button; GtkStateType state_type; GtkShadowType shadow_type; - GdkRectangle restrict_area; - GdkRectangle new_area; gint x, y; gint indicator_size, indicator_spacing; + gint focus_width; + gint focus_pad; + gboolean interior_focus; - g_return_if_fail (GTK_IS_RADIO_BUTTON (check_button)); + widget = GTK_WIDGET (check_button); - if (GTK_WIDGET_VISIBLE (check_button) && GTK_WIDGET_MAPPED (check_button)) + if (gtk_widget_is_drawable (widget)) { - widget = GTK_WIDGET (check_button); button = GTK_BUTTON (check_button); toggle_button = GTK_TOGGLE_BUTTON (check_button); - state_type = GTK_WIDGET_STATE (widget); - if ((state_type != GTK_STATE_NORMAL) && - (state_type != GTK_STATE_PRELIGHT)) - state_type = GTK_STATE_NORMAL; + gtk_widget_style_get (widget, + "interior-focus", &interior_focus, + "focus-line-width", &focus_width, + "focus-padding", &focus_pad, + NULL); _gtk_check_button_get_props (check_button, &indicator_size, &indicator_spacing); - restrict_area.x = widget->allocation.x + GTK_CONTAINER (widget)->border_width; - restrict_area.y = widget->allocation.y + GTK_CONTAINER (widget)->border_width; - restrict_area.width = widget->allocation.width - ( 2 * GTK_CONTAINER (widget)->border_width); - restrict_area.height = widget->allocation.height - ( 2 * GTK_CONTAINER (widget)->border_width); - - if (gdk_rectangle_intersect (area, &restrict_area, &new_area)) - { - if (state_type != GTK_STATE_NORMAL) - gtk_paint_flat_box(widget->style, widget->window, state_type, - GTK_SHADOW_ETCHED_OUT, - area, widget, "radiobutton", - new_area.x, new_area.y, - new_area.width, new_area.height); - } - x = widget->allocation.x + indicator_spacing + GTK_CONTAINER (widget)->border_width; y = widget->allocation.y + (widget->allocation.height - indicator_size) / 2; - - if (GTK_TOGGLE_BUTTON (widget)->active) + + child = GTK_BIN (check_button)->child; + if (!interior_focus || !(child && gtk_widget_get_visible (child))) + x += focus_width + focus_pad; + + if (toggle_button->inconsistent) + shadow_type = GTK_SHADOW_ETCHED_IN; + else if (toggle_button->active) shadow_type = GTK_SHADOW_IN; else shadow_type = GTK_SHADOW_OUT; - if (GTK_TOGGLE_BUTTON (widget)->inconsistent) - shadow_type = GTK_SHADOW_ETCHED_IN; - + if (button->activate_timeout || (button->button_down && button->in_button)) + state_type = GTK_STATE_ACTIVE; + else if (button->in_button) + state_type = GTK_STATE_PRELIGHT; + else if (!gtk_widget_is_sensitive (widget)) + state_type = GTK_STATE_INSENSITIVE; + else + state_type = GTK_STATE_NORMAL; + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) x = widget->allocation.x + widget->allocation.width - (indicator_size + x - widget->allocation.x); + if (GTK_WIDGET_STATE (toggle_button) == GTK_STATE_PRELIGHT) + { + GdkRectangle restrict_area; + GdkRectangle new_area; + + restrict_area.x = widget->allocation.x + GTK_CONTAINER (widget)->border_width; + restrict_area.y = widget->allocation.y + GTK_CONTAINER (widget)->border_width; + restrict_area.width = widget->allocation.width - (2 * GTK_CONTAINER (widget)->border_width); + restrict_area.height = widget->allocation.height - (2 * GTK_CONTAINER (widget)->border_width); + + if (gdk_rectangle_intersect (area, &restrict_area, &new_area)) + { + gtk_paint_flat_box (widget->style, widget->window, GTK_STATE_PRELIGHT, + GTK_SHADOW_ETCHED_OUT, + area, widget, "checkbutton", + new_area.x, new_area.y, + new_area.width, new_area.height); + } + } + gtk_paint_option (widget->style, widget->window, - GTK_WIDGET_STATE (widget), shadow_type, + state_type, shadow_type, area, widget, "radiobutton", x, y, indicator_size, indicator_size); } } + +#define __GTK_RADIO_BUTTON_C__ +#include "gtkaliasdef.c"