X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkcheckbutton.c;h=d7df5a914e98f9c71ba306b063bf294af767b64a;hb=HEAD;hp=802b85e017f78f7793bd1a6732b2870aa79ba435;hpb=c626cd4233c03dc5a1ec81a2b272e59bed285c85;p=~andy%2Fgtk diff --git a/gtk/gtkcheckbutton.c b/gtk/gtkcheckbutton.c index 802b85e01..d7df5a914 100644 --- a/gtk/gtkcheckbutton.c +++ b/gtk/gtkcheckbutton.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 . */ /* @@ -24,147 +22,156 @@ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ +#include "config.h" + #include "gtkcheckbutton.h" -#include "gtkintl.h" + +#include "gtkbuttonprivate.h" #include "gtklabel.h" +#include "gtkprivate.h" +#include "gtkintl.h" + + +/** + * SECTION:gtkcheckbutton + * @Short_description: Create widgets with a discrete toggle button + * @Title: GtkCheckButton + * @See_also: #GtkCheckMenuItem, #GtkButton, #GtkToggleButton, #GtkRadioButton + * + * A #GtkCheckButton places a discrete #GtkToggleButton next to a widget, + * (usually a #GtkLabel). See the section on #GtkToggleButton widgets for + * more information about toggle/check buttons. + * + * The important signal ( #GtkToggleButton::toggled ) is also inherited from + * #GtkToggleButton. + */ + -#define INDICATOR_SIZE 13 +#define INDICATOR_SIZE 16 #define INDICATOR_SPACING 2 -static void gtk_check_button_class_init (GtkCheckButtonClass *klass); -static void gtk_check_button_init (GtkCheckButton *check_button); -static void gtk_check_button_size_request (GtkWidget *widget, - GtkRequisition *requisition); +static void gtk_check_button_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural); +static void gtk_check_button_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural); static void gtk_check_button_size_allocate (GtkWidget *widget, GtkAllocation *allocation); -static gint gtk_check_button_expose (GtkWidget *widget, - GdkEventExpose *event); +static gboolean gtk_check_button_draw (GtkWidget *widget, + cairo_t *cr); static void gtk_check_button_paint (GtkWidget *widget, - GdkRectangle *area); + cairo_t *cr); static void gtk_check_button_draw_indicator (GtkCheckButton *check_button, - GdkRectangle *area); + cairo_t *cr); static void gtk_real_check_button_draw_indicator (GtkCheckButton *check_button, - GdkRectangle *area); + cairo_t *cr); -static GtkToggleButtonClass *parent_class = NULL; - - -GtkType -gtk_check_button_get_type (void) -{ - static GtkType check_button_type = 0; - - if (!check_button_type) - { - static const GtkTypeInfo check_button_info = - { - "GtkCheckButton", - sizeof (GtkCheckButton), - sizeof (GtkCheckButtonClass), - (GtkClassInitFunc) gtk_check_button_class_init, - (GtkObjectInitFunc) gtk_check_button_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - check_button_type = gtk_type_unique (GTK_TYPE_TOGGLE_BUTTON, &check_button_info); - } - - return check_button_type; -} +G_DEFINE_TYPE (GtkCheckButton, gtk_check_button, GTK_TYPE_TOGGLE_BUTTON) static void gtk_check_button_class_init (GtkCheckButtonClass *class) { GtkWidgetClass *widget_class; - + widget_class = (GtkWidgetClass*) class; - parent_class = gtk_type_class (gtk_toggle_button_get_type ()); - - widget_class->size_request = gtk_check_button_size_request; + + widget_class->get_preferred_width = gtk_check_button_get_preferred_width; + widget_class->get_preferred_height = gtk_check_button_get_preferred_height; widget_class->size_allocate = gtk_check_button_size_allocate; - widget_class->expose_event = gtk_check_button_expose; + widget_class->draw = gtk_check_button_draw; class->draw_indicator = gtk_real_check_button_draw_indicator; + gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_CHECK_BOX); + gtk_widget_class_install_style_property (widget_class, - g_param_spec_int ("indicator_size", - _("Indicator Size"), - _("Size of check or radio indicator"), + g_param_spec_int ("indicator-size", + P_("Indicator Size"), + P_("Size of check or radio indicator"), 0, G_MAXINT, INDICATOR_SIZE, - G_PARAM_READABLE)); + GTK_PARAM_READABLE)); gtk_widget_class_install_style_property (widget_class, - g_param_spec_int ("indicator_spacing", - _("Indicator Spacing"), - _("Spacing around check or radio indicator"), + g_param_spec_int ("indicator-spacing", + P_("Indicator Spacing"), + P_("Spacing around check or radio indicator"), 0, G_MAXINT, INDICATOR_SPACING, - G_PARAM_READABLE)); + GTK_PARAM_READABLE)); +} + +static void +draw_indicator_changed (GObject *object, + GParamSpec *pspec, + gpointer user_data) +{ + GtkButton *button = GTK_BUTTON (object); + + if (gtk_toggle_button_get_mode (GTK_TOGGLE_BUTTON (button))) + gtk_button_set_alignment (button, 0.0, 0.5); + else + gtk_button_set_alignment (button, 0.5, 0.5); } static void gtk_check_button_init (GtkCheckButton *check_button) { - GTK_WIDGET_SET_FLAGS (check_button, GTK_NO_WINDOW); - GTK_WIDGET_UNSET_FLAGS (check_button, GTK_RECEIVES_DEFAULT); - GTK_TOGGLE_BUTTON (check_button)->draw_indicator = TRUE; + gtk_widget_set_receives_default (GTK_WIDGET (check_button), FALSE); + g_signal_connect (check_button, "notify::draw-indicator", G_CALLBACK (draw_indicator_changed), NULL); + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (check_button), TRUE); } +/** + * gtk_check_button_new: + * + * Creates a new #GtkCheckButton. + * + * Returns: a #GtkWidget. + */ GtkWidget* gtk_check_button_new (void) { - return gtk_widget_new (GTK_TYPE_CHECK_BUTTON, NULL); + return g_object_new (GTK_TYPE_CHECK_BUTTON, NULL); } +/** + * gtk_check_button_new_with_label: + * @label: the text for the check button. + * + * Creates a new #GtkCheckButton with a #GtkLabel to the right of it. + * + * Returns: a #GtkWidget. + */ GtkWidget* gtk_check_button_new_with_label (const gchar *label) { - GtkWidget *check_button; - GtkWidget *label_widget; - - check_button = gtk_check_button_new (); - label_widget = gtk_label_new (label); - gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5); - - gtk_container_add (GTK_CONTAINER (check_button), label_widget); - gtk_widget_show (label_widget); - - return check_button; + return g_object_new (GTK_TYPE_CHECK_BUTTON, "label", label, NULL); } /** * gtk_check_button_new_with_mnemonic: * @label: The text of the button, with an underscore in front of the - * mnemonic character - * @returns: a new #GtkCheckButton + * mnemonic character + * + * Creates a new #GtkCheckButton containing a label. The label + * will be created using gtk_label_new_with_mnemonic(), so underscores + * in @label indicate the mnemonic for the check button. * - * Creates a new #GtkCheckButton containing a label. - * If characters in @label are preceded by an underscore, they are underlined - * indicating that they represent a keyboard accelerator called a mnemonic. - * Pressing Alt and that key activates the checkbutton. - **/ + * Returns: a new #GtkCheckButton + */ GtkWidget* gtk_check_button_new_with_mnemonic (const gchar *label) { - GtkWidget *check_button; - GtkWidget *label_widget; - - check_button = gtk_check_button_new (); - label_widget = gtk_label_new_with_mnemonic (label); - gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5); - gtk_label_set_mnemonic_widget (GTK_LABEL (label_widget), check_button); - - gtk_container_add (GTK_CONTAINER (check_button), label_widget); - gtk_widget_show (label_widget); - - return check_button; + return g_object_new (GTK_TYPE_CHECK_BUTTON, + "label", label, + "use-underline", TRUE, + NULL); } @@ -173,42 +180,49 @@ gtk_check_button_new_with_mnemonic (const gchar *label) */ static void gtk_check_button_paint (GtkWidget *widget, - GdkRectangle *area) + cairo_t *cr) { GtkCheckButton *check_button = GTK_CHECK_BUTTON (widget); - - if (GTK_WIDGET_DRAWABLE (widget)) + + gtk_check_button_draw_indicator (check_button, cr); + + if (gtk_widget_has_visible_focus (widget)) { + GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget)); + GtkStyleContext *context; + GtkAllocation allocation; gint border_width; gint interior_focus; - - gtk_widget_style_get (widget, "interior_focus", &interior_focus, NULL); + gint focus_width; + gint focus_pad; - gtk_check_button_draw_indicator (check_button, area); - - border_width = GTK_CONTAINER (widget)->border_width; - if (GTK_WIDGET_HAS_FOCUS (widget)) - { - if (interior_focus) - { - GtkWidget *child = GTK_BIN (widget)->child; - - if (child && GTK_WIDGET_VISIBLE (child)) - gtk_paint_focus (widget->style, widget->window, - NULL, widget, "checkbutton", - child->allocation.x - 1, - child->allocation.y - 1, - child->allocation.width + 1, - child->allocation.height + 1); - } - else - gtk_paint_focus (widget->style, widget->window, - NULL, widget, "checkbutton", - border_width + widget->allocation.x, - border_width + widget->allocation.y, - widget->allocation.width - 2 * border_width - 1, - widget->allocation.height - 2 * border_width - 1); - } + 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_get_allocation (widget, &allocation); + context = gtk_widget_get_style_context (widget); + + if (interior_focus && child && gtk_widget_get_visible (child)) + { + GtkAllocation child_allocation; + + gtk_widget_get_allocation (child, &child_allocation); + gtk_render_focus (context, cr, + child_allocation.x - allocation.x - focus_width - focus_pad, + child_allocation.y - allocation.y - focus_width - focus_pad, + child_allocation.width + 2 * (focus_width + focus_pad), + child_allocation.height + 2 * (focus_width + focus_pad)); + } + else + gtk_render_focus (context, cr, + border_width, border_width, + allocation.width - 2 * border_width, + allocation.height - 2 * border_width); } } @@ -220,56 +234,105 @@ _gtk_check_button_get_props (GtkCheckButton *check_button, GtkWidget *widget = GTK_WIDGET (check_button); if (indicator_size) - gtk_widget_style_get (widget, "indicator_size", indicator_size, NULL); + gtk_widget_style_get (widget, "indicator-size", indicator_size, NULL); if (indicator_spacing) - gtk_widget_style_get (widget, "indicator_spacing", indicator_spacing, NULL); + gtk_widget_style_get (widget, "indicator-spacing", indicator_spacing, NULL); } static void -gtk_check_button_size_request (GtkWidget *widget, - GtkRequisition *requisition) +gtk_check_button_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural) { - GtkToggleButton *toggle_button; - - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_CHECK_BUTTON (widget)); - g_return_if_fail (requisition != NULL); + GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (widget); - toggle_button = GTK_TOGGLE_BUTTON (widget); - - if (toggle_button->draw_indicator) + if (gtk_toggle_button_get_mode (toggle_button)) + { + GtkWidget *child; + gint indicator_size; + gint indicator_spacing; + gint focus_width; + gint focus_pad; + guint border_width; + + border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); + + gtk_widget_style_get (GTK_WIDGET (widget), + "focus-line-width", &focus_width, + "focus-padding", &focus_pad, + NULL); + *minimum = 2 * border_width; + *natural = 2 * border_width; + + _gtk_check_button_get_props (GTK_CHECK_BUTTON (widget), + &indicator_size, &indicator_spacing); + + child = gtk_bin_get_child (GTK_BIN (widget)); + if (child && gtk_widget_get_visible (child)) + { + gint child_min, child_nat; + + gtk_widget_get_preferred_width (child, &child_min, &child_nat); + + *minimum += child_min + indicator_spacing; + *natural += child_nat + indicator_spacing; + } + + *minimum += (indicator_size + indicator_spacing * 2 + 2 * (focus_width + focus_pad)); + *natural += (indicator_size + indicator_spacing * 2 + 2 * (focus_width + focus_pad)); + } + else + GTK_WIDGET_CLASS (gtk_check_button_parent_class)->get_preferred_width (widget, minimum, natural); +} + +static void +gtk_check_button_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (widget); + + if (gtk_toggle_button_get_mode (toggle_button)) { GtkWidget *child; gint temp; gint indicator_size; gint indicator_spacing; - gint border_width = GTK_CONTAINER (widget)->border_width; - - requisition->width = border_width + 2; - requisition->height = border_width + 2; + gint focus_width; + gint focus_pad; + guint border_width; + + border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); + + gtk_widget_style_get (GTK_WIDGET (widget), + "focus-line-width", &focus_width, + "focus-padding", &focus_pad, + NULL); + + *minimum = border_width * 2; + *natural = border_width * 2; - child = GTK_BIN (widget)->child; - if (child && GTK_WIDGET_VISIBLE (child)) - { - GtkRequisition child_requisition; - - gtk_widget_size_request (child, &child_requisition); - - requisition->width += child_requisition.width; - requisition->height += child_requisition.height; - } - _gtk_check_button_get_props (GTK_CHECK_BUTTON (widget), - &indicator_size, &indicator_spacing); - - requisition->width += (indicator_size + indicator_spacing * 3 + 2); - - temp = (indicator_size + indicator_spacing * 2); - requisition->height = MAX (requisition->height, temp) + 2; + &indicator_size, &indicator_spacing); + + child = gtk_bin_get_child (GTK_BIN (widget)); + if (child && gtk_widget_get_visible (child)) + { + gint child_min, child_nat; + + gtk_widget_get_preferred_height (child, &child_min, &child_nat); + + *minimum += child_min; + *natural += child_nat; + } + + temp = indicator_size + indicator_spacing * 2; + *minimum = MAX (*minimum, temp) + 2 * (focus_width + focus_pad); + *natural = MAX (*natural, temp) + 2 * (focus_width + focus_pad); } else - (* GTK_WIDGET_CLASS (parent_class)->size_request) (widget, requisition); + GTK_WIDGET_CLASS (gtk_check_button_parent_class)->get_preferred_height (widget, minimum, natural); } static void @@ -280,177 +343,174 @@ gtk_check_button_size_allocate (GtkWidget *widget, GtkToggleButton *toggle_button; GtkButton *button; GtkAllocation child_allocation; - - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_CHECK_BUTTON (widget)); - g_return_if_fail (allocation != NULL); - + + button = GTK_BUTTON (widget); check_button = GTK_CHECK_BUTTON (widget); toggle_button = GTK_TOGGLE_BUTTON (widget); - if (toggle_button->draw_indicator) + if (gtk_toggle_button_get_mode (toggle_button)) { + GtkWidget *child; gint indicator_size; gint indicator_spacing; + gint focus_width; + gint focus_pad; _gtk_check_button_get_props (check_button, &indicator_size, &indicator_spacing); - - widget->allocation = *allocation; - if (GTK_WIDGET_REALIZED (widget)) - gdk_window_move_resize (toggle_button->event_window, + gtk_widget_style_get (widget, + "focus-line-width", &focus_width, + "focus-padding", &focus_pad, + NULL); + + gtk_widget_set_allocation (widget, allocation); + + if (gtk_widget_get_realized (widget)) + gdk_window_move_resize (gtk_button_get_event_window (button), allocation->x, allocation->y, allocation->width, allocation->height); - - button = GTK_BUTTON (widget); - - if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child)) + + child = gtk_bin_get_child (GTK_BIN (button)); + if (child && gtk_widget_get_visible (child)) { - gint border_width = GTK_CONTAINER (widget)->border_width; - - child_allocation.x = (border_width + indicator_size + indicator_spacing * 3 + 1 + - widget->allocation.x); - child_allocation.y = border_width + 1 + widget->allocation.y; - child_allocation.width = MAX (1, allocation->width - - (border_width + indicator_size + indicator_spacing * 3 + 1) - - border_width - 1); - child_allocation.height = MAX (1, allocation->height - (border_width + 1) * 2); + guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); + + child_allocation.width = allocation->width - + ((border_width + focus_width + focus_pad) * 2 + indicator_size + indicator_spacing * 3); + child_allocation.width = MAX (child_allocation.width, 1); + + child_allocation.height = allocation->height - (border_width + focus_width + focus_pad) * 2; + child_allocation.height = MAX (child_allocation.height, 1); + child_allocation.x = (border_width + indicator_size + indicator_spacing * 3 + + allocation->x + focus_width + focus_pad); + child_allocation.y = allocation->y + (allocation->height - child_allocation.height) / 2; + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) child_allocation.x = allocation->x + allocation->width - (child_allocation.x - allocation->x + child_allocation.width); - gtk_widget_size_allocate (GTK_BIN (button)->child, &child_allocation); + gtk_widget_size_allocate (child, &child_allocation); } } else - (* GTK_WIDGET_CLASS (parent_class)->size_allocate) (widget, allocation); + GTK_WIDGET_CLASS (gtk_check_button_parent_class)->size_allocate (widget, allocation); } static gint -gtk_check_button_expose (GtkWidget *widget, - GdkEventExpose *event) +gtk_check_button_draw (GtkWidget *widget, + cairo_t *cr) { - GtkCheckButton *check_button; GtkToggleButton *toggle_button; GtkBin *bin; + GtkWidget *child; - g_return_val_if_fail (widget != NULL, FALSE); - g_return_val_if_fail (GTK_IS_CHECK_BUTTON (widget), FALSE); - g_return_val_if_fail (event != NULL, FALSE); - - check_button = GTK_CHECK_BUTTON (widget); toggle_button = GTK_TOGGLE_BUTTON (widget); bin = GTK_BIN (widget); - - if (GTK_WIDGET_DRAWABLE (widget)) + + if (gtk_toggle_button_get_mode (toggle_button)) { - if (toggle_button->draw_indicator) - { - gtk_check_button_paint (widget, &event->area); - - if (bin->child) - gtk_container_propagate_expose (GTK_CONTAINER (widget), - bin->child, - event); - } - else if (GTK_WIDGET_CLASS (parent_class)->expose_event) - (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event); + gtk_check_button_paint (widget, cr); + + child = gtk_bin_get_child (bin); + if (child) + gtk_container_propagate_draw (GTK_CONTAINER (widget), + child, + cr); } - + else if (GTK_WIDGET_CLASS (gtk_check_button_parent_class)->draw) + GTK_WIDGET_CLASS (gtk_check_button_parent_class)->draw (widget, cr); + return FALSE; } static void gtk_check_button_draw_indicator (GtkCheckButton *check_button, - GdkRectangle *area) + cairo_t *cr) { - GtkCheckButtonClass *class; - - g_return_if_fail (check_button != NULL); - g_return_if_fail (GTK_IS_CHECK_BUTTON (check_button)); - - class = GTK_CHECK_BUTTON_GET_CLASS (check_button); - + GtkCheckButtonClass *class = GTK_CHECK_BUTTON_GET_CLASS (check_button); + if (class->draw_indicator) - (* class->draw_indicator) (check_button, area); + class->draw_indicator (check_button, cr); } static void gtk_real_check_button_draw_indicator (GtkCheckButton *check_button, - GdkRectangle *area) + cairo_t *cr) { GtkWidget *widget; + GtkWidget *child; + GtkButton *button; GtkToggleButton *toggle_button; - GtkStateType state_type; - GtkShadowType shadow_type; - GdkRectangle restrict_area; - GdkRectangle new_area; - gint width, height; + GtkStateFlags state = 0; gint x, y; gint indicator_size; gint indicator_spacing; - GdkWindow *window; - - g_return_if_fail (check_button != NULL); - g_return_if_fail (GTK_IS_CHECK_BUTTON (check_button)); - + gint focus_width; + gint focus_pad; + guint border_width; + gboolean interior_focus; + GtkAllocation allocation; + GtkStyleContext *context; + widget = GTK_WIDGET (check_button); + button = GTK_BUTTON (check_button); toggle_button = GTK_TOGGLE_BUTTON (check_button); - - if (GTK_WIDGET_DRAWABLE (check_button)) - { - window = widget->window; - - _gtk_check_button_get_props (check_button, &indicator_size, &indicator_spacing); - - state_type = GTK_WIDGET_STATE (widget); - if (state_type != GTK_STATE_NORMAL && - state_type != GTK_STATE_PRELIGHT) - state_type = GTK_STATE_NORMAL; - - 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, window, state_type, - GTK_SHADOW_ETCHED_OUT, - area, widget, "checkbutton", - 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; - width = indicator_size; - height = indicator_size; - if (GTK_TOGGLE_BUTTON (widget)->inconsistent) - { - state_type = GTK_WIDGET_STATE (widget) == GTK_STATE_ACTIVE ? GTK_STATE_NORMAL : GTK_WIDGET_STATE (widget); - shadow_type = GTK_SHADOW_ETCHED_IN; - } - else if (GTK_TOGGLE_BUTTON (widget)->active) - { - state_type = GTK_STATE_ACTIVE; - shadow_type = GTK_SHADOW_IN; - } - else - { - shadow_type = GTK_SHADOW_OUT; - state_type = GTK_WIDGET_STATE (widget); - } + gtk_widget_get_allocation (widget, &allocation); + context = gtk_widget_get_style_context (widget); + state = gtk_widget_get_state_flags (widget); - if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) - x = widget->allocation.x + widget->allocation.width - (width + x - widget->allocation.x); + gtk_widget_style_get (widget, + "interior-focus", &interior_focus, + "focus-line-width", &focus_width, + "focus-padding", &focus_pad, + NULL); - gtk_paint_check (widget->style, window, - state_type, shadow_type, - area, widget, "checkbutton", - x, y, width, height); - } + _gtk_check_button_get_props (check_button, &indicator_size, &indicator_spacing); + + border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); + + x = indicator_spacing + border_width; + y = (allocation.height - indicator_size) / 2; + + child = gtk_bin_get_child (GTK_BIN (check_button)); + if (!interior_focus || !(child && gtk_widget_get_visible (child))) + x += focus_width + focus_pad; + + state &= ~(GTK_STATE_FLAG_INCONSISTENT | + GTK_STATE_FLAG_ACTIVE | + GTK_STATE_FLAG_SELECTED | + GTK_STATE_FLAG_PRELIGHT); + + if (gtk_toggle_button_get_inconsistent (toggle_button)) + state |= GTK_STATE_FLAG_INCONSISTENT; + else if (gtk_toggle_button_get_active (toggle_button) || + (button->priv->button_down && button->priv->in_button)) + state |= GTK_STATE_FLAG_ACTIVE; + + 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_PRELIGHT; + + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) + x = allocation.width - (indicator_size + x); + + 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_CHECK); + + gtk_render_check (context, cr, + x, y, indicator_size, indicator_size); + + gtk_style_context_restore (context); }