X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkradiobutton.c;h=82ab28cb9da467ae73eac8844675c8daffc136ce;hb=HEAD;hp=24300334c990e1afaf1c96466f286f9fd6477abe;hpb=68701c828c00e6ae826cc6a6df66da78457329ff;p=~andy%2Fgtk diff --git a/gtk/gtkradiobutton.c b/gtk/gtkradiobutton.c index 24300334c..82ab28cb9 100644 --- a/gtk/gtkradiobutton.c +++ b/gtk/gtkradiobutton.c @@ -12,9 +12,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ /* @@ -25,13 +23,15 @@ */ #include "config.h" + +#include "gtkradiobutton.h" + +#include "gtkbuttonprivate.h" #include "gtklabel.h" #include "gtkmarshalers.h" -#include "gtkradiobutton.h" #include "gtkprivate.h" #include "gtkintl.h" -#include "gtkalias.h" - +#include "a11y/gtkradiobuttonaccessible.h" /** * SECTION:gtkradiobutton @@ -75,7 +75,8 @@ * * GtkWidget *window, *radio1, *radio2, *box, *entry; * window = gtk_window_new (GTK_WINDOW_TOPLEVEL); - * box = gtk_vbox_new (TRUE, 2); + * box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + * gtk_box_set_homogeneous (GTK_BOX (box), TRUE); * * /* Create a radio button with a GtkEntry widget */ * radio1 = gtk_radio_button_new (NULL); @@ -105,18 +106,23 @@ */ +struct _GtkRadioButtonPrivate +{ + GSList *group; +}; + enum { PROP_0, PROP_GROUP }; -static void gtk_radio_button_destroy (GtkObject *object); +static void gtk_radio_button_destroy (GtkWidget *widget); 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); + cairo_t *cr); static void gtk_radio_button_set_property (GObject *object, guint prop_id, const GValue *value, @@ -134,13 +140,11 @@ 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; @@ -160,8 +164,7 @@ gtk_radio_button_class_init (GtkRadioButtonClass *class) 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->destroy = gtk_radio_button_destroy; widget_class->focus = gtk_radio_button_focus; button_class->clicked = gtk_radio_button_clicked; @@ -172,7 +175,7 @@ gtk_radio_button_class_init (GtkRadioButtonClass *class) /** * GtkRadioButton::group-changed: - * @style: the object which received the signal + * @button: 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 @@ -184,28 +187,38 @@ gtk_radio_button_class_init (GtkRadioButtonClass *class) * Since: 2.4 */ group_changed_signal = g_signal_new (I_("group-changed"), - G_OBJECT_CLASS_TYPE (object_class), + G_OBJECT_CLASS_TYPE (gobject_class), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GtkRadioButtonClass, group_changed), NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); + + g_type_class_add_private (class, sizeof (GtkRadioButtonPrivate)); + + gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_RADIO_BUTTON_ACCESSIBLE); } static void gtk_radio_button_init (GtkRadioButton *radio_button) { - gtk_widget_set_has_window (GTK_WIDGET (radio_button), FALSE); + GtkRadioButtonPrivate *priv; + + radio_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (radio_button, + GTK_TYPE_RADIO_BUTTON, + GtkRadioButtonPrivate); + priv = radio_button->priv; + gtk_widget_set_receives_default (GTK_WIDGET (radio_button), FALSE); - GTK_TOGGLE_BUTTON (radio_button)->active = TRUE; + _gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_button), TRUE); - GTK_BUTTON (radio_button)->depress_on_activate = FALSE; + GTK_BUTTON (radio_button)->priv->depress_on_activate = FALSE; - radio_button->group = g_slist_prepend (NULL, radio_button); + priv->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); + gtk_widget_set_state_flags (GTK_WIDGET (radio_button), GTK_STATE_FLAG_ACTIVE, TRUE); } static void @@ -255,8 +268,8 @@ gtk_radio_button_get_property (GObject *object, /** * gtk_radio_button_set_group: * @radio_button: a #GtkRadioButton. - * @group: an existing radio button group, such as one returned from - * gtk_radio_button_get_group(). + * @group: (transfer none) (element-type GtkRadioButton): an existing radio + * button group, such as one returned from gtk_radio_button_get_group(). * * Sets a #GtkRadioButton's group. It should be noted that this does not change * the layout of your interface in any way, so if you are changing the group, @@ -267,36 +280,39 @@ void gtk_radio_button_set_group (GtkRadioButton *radio_button, GSList *group) { + GtkRadioButtonPrivate *priv; 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) + priv = radio_button->priv; + + if (priv->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) + priv->group = g_slist_remove (priv->group, radio_button); + + if (priv->group && !priv->group->next) + old_group_singleton = g_object_ref (priv->group->data); + + for (slist = priv->group; slist; slist = slist->next) { GtkRadioButton *tmp_button; tmp_button = slist->data; - - tmp_button->group = radio_button->group; + + tmp_button->priv->group = priv->group; } } if (group && !group->next) new_group_singleton = g_object_ref (group->data); - - radio_button->group = g_slist_prepend (group, radio_button); - + + priv->group = g_slist_prepend (group, radio_button); + if (group) { GSList *slist; @@ -306,8 +322,8 @@ gtk_radio_button_set_group (GtkRadioButton *radio_button, GtkRadioButton *tmp_button; tmp_button = slist->data; - - tmp_button->group = radio_button->group; + + tmp_button->priv->group = priv->group; } } @@ -331,14 +347,70 @@ gtk_radio_button_set_group (GtkRadioButton *radio_button, g_object_unref (radio_button); } +/** + * gtk_radio_button_join_group: + * @radio_button: the #GtkRadioButton object + * @group_source: (allow-none): a radio button object whos group we are + * joining, or %NULL to remove the radio button from its group + * + * Joins a #GtkRadioButton object to the group of another #GtkRadioButton object + * + * Use this in language bindings instead of the gtk_radio_button_get_group() + * and gtk_radio_button_set_group() methods + * + * A common way to set up a group of radio buttons is the following: + * |[ + * GtkRadioButton *radio_button; + * GtkRadioButton *last_button; + * + * while (/* more buttons to add */) + * { + * radio_button = gtk_radio_button_new (...); + * + * gtk_radio_button_join_group (radio_button, last_button); + * last_button = radio_button; + * } + * ]| + * + * Since: 3.0 + */ +void +gtk_radio_button_join_group (GtkRadioButton *radio_button, + GtkRadioButton *group_source) +{ + g_return_if_fail (GTK_IS_RADIO_BUTTON (radio_button)); + g_return_if_fail (group_source == NULL || GTK_IS_RADIO_BUTTON (group_source)); + + if (group_source) + { + GSList *group; + group = gtk_radio_button_get_group (group_source); + + if (!group) + { + /* if we are not already part of a group we need to set up a new one + and then get the newly created group */ + gtk_radio_button_set_group (group_source, NULL); + group = gtk_radio_button_get_group (group_source); + } + + gtk_radio_button_set_group (radio_button, group); + } + else + { + gtk_radio_button_set_group (radio_button, NULL); + } +} + /** * gtk_radio_button_new: - * @group: an existing radio button group, or %NULL if you are creating a new group. + * @group: (element-type GtkRadioButton) (allow-none): an existing + * radio button group, or %NULL if you are creating a new group. * * Creates a new #GtkRadioButton. To be of any practical value, a widget should * then be packed into the radio button. * - * Returns: a new radio button. + * Returns: a new radio button */ GtkWidget* gtk_radio_button_new (GSList *group) @@ -355,8 +427,8 @@ gtk_radio_button_new (GSList *group) /** * gtk_radio_button_new_with_label: - * @group: an existing radio button group, or %NULL if you are creating a new - * group. + * @group: (element-type GtkRadioButton) (allow-none): an existing + * radio button group, or %NULL if you are creating a new group. * @label: the text label to display next to the radio button. * * Creates a new #GtkRadioButton with a text label. @@ -380,16 +452,18 @@ gtk_radio_button_new_with_label (GSList *group, /** * gtk_radio_button_new_with_mnemonic: - * @group: the radio button group + * @group: (element-type GtkRadioButton) (allow-none): the radio button + * group * @label: the text of the button, with an underscore in front of the * mnemonic character - * @returns: a new #GtkRadioButton * - * 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 + * 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. - **/ + * + * Returns: a new #GtkRadioButton + */ GtkWidget* gtk_radio_button_new_with_mnemonic (GSList *group, const gchar *label) @@ -408,13 +482,14 @@ gtk_radio_button_new_with_mnemonic (GSList *group, } /** - * gtk_radio_button_new_from_widget: - * @radio_group_member: an existing #GtkRadioButton. + * gtk_radio_button_new_from_widget: (constructor) + * @radio_group_member: (allow-none): an existing #GtkRadioButton. * - * Creates a new #GtkRadioButton, adding it to the same group as @radio_group_member. - * As with gtk_radio_button_new(), a widget should be packed into the radio button. + * Creates a new #GtkRadioButton, adding it to the same group as + * @radio_group_member. As with gtk_radio_button_new(), a widget + * should be packed into the radio button. * - * Returns: a new radio button. + * Returns: (transfer none): a new radio button. */ GtkWidget* gtk_radio_button_new_from_widget (GtkRadioButton *radio_group_member) @@ -426,14 +501,14 @@ gtk_radio_button_new_from_widget (GtkRadioButton *radio_group_member) } /** - * gtk_radio_button_new_with_label_from_widget: - * @radio_group_member: widget to get radio group from or %NULL + * gtk_radio_button_new_with_label_from_widget: (constructor) + * @radio_group_member: (allow-none): widget to get radio group from or %NULL * @label: a text string to display next to the radio button. * - * Creates a new #GtkRadioButton with a text label, adding it to the same group - * as @radio_group_member. + * Creates a new #GtkRadioButton with a text label, adding it to + * the same group as @radio_group_member. * - * Returns: a new radio button. + * Returns: (transfer none): a new radio button. */ GtkWidget* gtk_radio_button_new_with_label_from_widget (GtkRadioButton *radio_group_member, @@ -446,15 +521,16 @@ gtk_radio_button_new_with_label_from_widget (GtkRadioButton *radio_group_member, } /** - * gtk_radio_button_new_with_mnemonic_from_widget: + * gtk_radio_button_new_with_mnemonic_from_widget: (constructor) * @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 * * 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. + * + * Returns: (transfer none): a new #GtkRadioButton **/ GtkWidget* gtk_radio_button_new_with_mnemonic_from_widget (GtkRadioButton *radio_group_member, @@ -483,46 +559,45 @@ gtk_radio_button_get_group (GtkRadioButton *radio_button) { g_return_val_if_fail (GTK_IS_RADIO_BUTTON (radio_button), NULL); - return radio_button->group; + return radio_button->priv->group; } static void -gtk_radio_button_destroy (GtkObject *object) +gtk_radio_button_destroy (GtkWidget *widget) { GtkWidget *old_group_singleton = NULL; - GtkRadioButton *radio_button; + GtkRadioButton *radio_button = GTK_RADIO_BUTTON (widget); + GtkRadioButtonPrivate *priv = radio_button->priv; GtkRadioButton *tmp_button; GSList *tmp_list; 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; + was_in_group = priv->group && priv->group->next; - tmp_list = radio_button->group; + priv->group = g_slist_remove (priv->group, radio_button); + if (priv->group && !priv->group->next) + old_group_singleton = priv->group->data; + + tmp_list = priv->group; while (tmp_list) { tmp_button = tmp_list->data; tmp_list = tmp_list->next; - tmp_button->group = radio_button->group; + tmp_button->priv->group = priv->group; } /* this button is no longer in the group */ - radio_button->group = NULL; + priv->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); + GTK_WIDGET_CLASS (gtk_radio_button_parent_class)->destroy (widget); } static void @@ -531,9 +606,12 @@ get_coordinates (GtkWidget *widget, gint *x, gint *y) { - *x = widget->allocation.x + widget->allocation.width / 2; - *y = widget->allocation.y + widget->allocation.height / 2; - + GtkAllocation allocation; + + gtk_widget_get_allocation (widget, &allocation); + *x = allocation.x + allocation.width / 2; + *y = allocation.y + allocation.height / 2; + gtk_widget_translate_coordinates (widget, reference, *x, *y, x, y); } @@ -574,12 +652,13 @@ gtk_radio_button_focus (GtkWidget *widget, GtkDirectionType direction) { GtkRadioButton *radio_button = GTK_RADIO_BUTTON (widget); + GtkRadioButtonPrivate *priv = radio_button->priv; 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) + if (!gtk_toggle_button_get_mode (GTK_TOGGLE_BUTTON (widget))) return GTK_WIDGET_CLASS (gtk_radio_button_parent_class)->focus (widget, direction); if (gtk_widget_is_focus (widget)) @@ -595,12 +674,12 @@ gtk_radio_button_focus (GtkWidget *widget, { case GTK_DIR_LEFT: case GTK_DIR_RIGHT: - focus_list = g_slist_copy (radio_button->group); + focus_list = g_slist_copy (priv->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_copy (priv->group); focus_list = g_slist_sort_with_data (focus_list, up_down_compare, toplevel); break; case GTK_DIR_TAB_FORWARD: @@ -690,10 +769,10 @@ gtk_radio_button_focus (GtkWidget *widget, * - there is no currently active radio button. */ - tmp_slist = radio_button->group; + tmp_slist = priv->group; while (tmp_slist) { - if (GTK_TOGGLE_BUTTON (tmp_slist->data)->active) + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (tmp_slist->data))) selected_button = tmp_slist->data; tmp_slist = tmp_slist->next; } @@ -709,31 +788,35 @@ gtk_radio_button_focus (GtkWidget *widget, static void gtk_radio_button_clicked (GtkButton *button) { - GtkToggleButton *toggle_button; - GtkRadioButton *radio_button; + GtkRadioButton *radio_button = GTK_RADIO_BUTTON (button); + GtkRadioButtonPrivate *priv = radio_button->priv; + GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (button); GtkToggleButton *tmp_button; - GtkStateType new_state; + GtkStateFlags new_state = 0; GSList *tmp_list; gint toggled; gboolean depressed; - radio_button = GTK_RADIO_BUTTON (button); - toggle_button = GTK_TOGGLE_BUTTON (button); toggled = FALSE; g_object_ref (GTK_WIDGET (button)); - if (toggle_button->active) + new_state = gtk_widget_get_state_flags (GTK_WIDGET (button)) & + ~(GTK_STATE_FLAG_PRELIGHT | + GTK_STATE_FLAG_ACTIVE); + + if (gtk_toggle_button_get_active (toggle_button)) { tmp_button = NULL; - tmp_list = radio_button->group; + tmp_list = priv->group; while (tmp_list) { tmp_button = tmp_list->data; tmp_list = tmp_list->next; - if (tmp_button->active && tmp_button != toggle_button) + if (tmp_button != toggle_button && + gtk_toggle_button_get_active (tmp_button)) break; tmp_button = NULL; @@ -741,45 +824,55 @@ gtk_radio_button_clicked (GtkButton *button) if (!tmp_button) { - new_state = (button->in_button ? GTK_STATE_PRELIGHT : GTK_STATE_ACTIVE); + if (button->priv->in_button) + new_state |= GTK_STATE_FLAG_PRELIGHT; + + new_state |= GTK_STATE_FLAG_ACTIVE; } else { toggled = TRUE; - toggle_button->active = !toggle_button->active; - new_state = (button->in_button ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL); + _gtk_toggle_button_set_active (toggle_button, + !gtk_toggle_button_get_active (toggle_button)); + + if (button->priv->in_button) + new_state |= GTK_STATE_FLAG_PRELIGHT; } } else { toggled = TRUE; - toggle_button->active = !toggle_button->active; - - tmp_list = radio_button->group; + _gtk_toggle_button_set_active (toggle_button, + !gtk_toggle_button_get_active (toggle_button)); + + tmp_list = priv->group; while (tmp_list) { tmp_button = tmp_list->data; tmp_list = tmp_list->next; - if (tmp_button->active && (tmp_button != toggle_button)) + if (gtk_toggle_button_get_active (tmp_button) && (tmp_button != toggle_button)) { gtk_button_clicked (GTK_BUTTON (tmp_button)); break; } } - new_state = (button->in_button ? GTK_STATE_PRELIGHT : GTK_STATE_ACTIVE); + if (button->priv->in_button) + new_state |= GTK_STATE_FLAG_PRELIGHT; + + new_state |= GTK_STATE_FLAG_ACTIVE; } - if (toggle_button->inconsistent) + if (gtk_toggle_button_get_inconsistent (toggle_button)) depressed = FALSE; - else if (button->in_button && button->button_down) - depressed = !toggle_button->active; + else if (button->priv->in_button && button->priv->button_down) + depressed = !gtk_toggle_button_get_active (toggle_button); else - depressed = toggle_button->active; + depressed = gtk_toggle_button_get_active (toggle_button); - if (gtk_widget_get_state (GTK_WIDGET (button)) != new_state) - gtk_widget_set_state (GTK_WIDGET (button), new_state); + if (gtk_widget_get_state_flags (GTK_WIDGET (button)) != new_state) + gtk_widget_set_state_flags (GTK_WIDGET (button), new_state, TRUE); if (toggled) { @@ -797,87 +890,80 @@ gtk_radio_button_clicked (GtkButton *button) static void gtk_radio_button_draw_indicator (GtkCheckButton *check_button, - GdkRectangle *area) + cairo_t *cr) { + GtkAllocation allocation; GtkWidget *widget; GtkWidget *child; GtkButton *button; GtkToggleButton *toggle_button; - GtkStateType state_type; - GtkShadowType shadow_type; + GtkStyleContext *context; + GtkStateFlags state = 0; gint x, y; gint indicator_size, indicator_spacing; gint focus_width; gint focus_pad; + guint border_width; gboolean interior_focus; widget = GTK_WIDGET (check_button); + button = GTK_BUTTON (check_button); + toggle_button = GTK_TOGGLE_BUTTON (check_button); + context = gtk_widget_get_style_context (widget); + state = gtk_widget_get_state_flags (widget); - if (gtk_widget_is_drawable (widget)) - { - button = GTK_BUTTON (check_button); - toggle_button = GTK_TOGGLE_BUTTON (check_button); + border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); - gtk_widget_style_get (widget, - "interior-focus", &interior_focus, - "focus-line-width", &focus_width, - "focus-padding", &focus_pad, - NULL); + 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); + _gtk_check_button_get_props (check_button, &indicator_size, &indicator_spacing); - x = widget->allocation.x + indicator_spacing + GTK_CONTAINER (widget)->border_width; - y = widget->allocation.y + (widget->allocation.height - indicator_size) / 2; + gtk_widget_get_allocation (widget, &allocation); - child = GTK_BIN (check_button)->child; - if (!interior_focus || !(child && gtk_widget_get_visible (child))) - x += focus_width + focus_pad; + x = indicator_spacing + border_width; + y = (allocation.height - indicator_size) / 2; - 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 (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; + child = gtk_bin_get_child (GTK_BIN (check_button)); + if (!interior_focus || !(child && gtk_widget_get_visible (child))) + x += focus_width + focus_pad; - if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) - x = widget->allocation.x + widget->allocation.width - (indicator_size + x - widget->allocation.x); + state &= ~(GTK_STATE_FLAG_INCONSISTENT | + GTK_STATE_FLAG_ACTIVE | + GTK_STATE_FLAG_SELECTED | + GTK_STATE_FLAG_PRELIGHT); - if (gtk_widget_get_state (widget) == 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); - } - } + if (gtk_toggle_button_get_inconsistent (toggle_button)) + state |= GTK_STATE_FLAG_INCONSISTENT; + else if (gtk_toggle_button_get_active (toggle_button)) + state |= GTK_STATE_FLAG_ACTIVE; - gtk_paint_option (widget->style, widget->window, - state_type, shadow_type, - area, widget, "radiobutton", - x, y, indicator_size, indicator_size); - } -} + if (button->priv->activate_timeout || + (button->priv->button_down && button->priv->in_button)) + state |= GTK_STATE_FLAG_SELECTED; + + if (button->priv->in_button && !(state & GTK_STATE_FLAG_INSENSITIVE)) + state |= GTK_STATE_FLAG_PRELIGHT; + + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) + x = allocation.width - (indicator_size + x); -#define __GTK_RADIO_BUTTON_C__ -#include "gtkaliasdef.c" + gtk_style_context_save (context); + gtk_style_context_set_state (context, state); + + if (state & GTK_STATE_FLAG_PRELIGHT) + gtk_render_background (context, cr, + border_width, border_width, + allocation.width - (2 * border_width), + allocation.height - (2 * border_width)); + + gtk_style_context_add_class (context, GTK_STYLE_CLASS_RADIO); + + gtk_render_option (context, cr, + x, y, indicator_size, indicator_size); + + gtk_style_context_restore (context); +}