/* GTK - The GIMP Toolkit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 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, see . */ /* * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ #include "config.h" #include "gtkcheckbutton.h" #include "gtkbuttonprivate.h" #include "gtklabel.h" #include "gtkintl.h" #include "gtkprivate.h" #include "gtkrender.h" #include "gtkwidgetprivate.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 16 #define INDICATOR_SPACING 2 static void gtk_check_button_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural); static void gtk_check_button_get_preferred_width_for_height (GtkWidget *widget, gint height, gint *minimum, gint *natural); static void gtk_check_button_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural); static void gtk_check_button_get_preferred_height_for_width (GtkWidget *widget, gint width, gint *minimum, gint *natural); static void gtk_check_button_get_preferred_height_and_baseline_for_width (GtkWidget *widget, gint width, gint *minimum, gint *natural, gint *minimum_baseline, gint *natural_baseline); static void gtk_check_button_size_allocate (GtkWidget *widget, GtkAllocation *allocation); static gboolean gtk_check_button_draw (GtkWidget *widget, cairo_t *cr); static void gtk_check_button_paint (GtkWidget *widget, cairo_t *cr); static void gtk_check_button_draw_indicator (GtkCheckButton *check_button, cairo_t *cr); static void gtk_real_check_button_draw_indicator (GtkCheckButton *check_button, cairo_t *cr); G_DEFINE_TYPE (GtkCheckButton, gtk_check_button, GTK_TYPE_TOGGLE_BUTTON) static void gtk_check_button_state_flags_changed (GtkWidget *widget, GtkStateFlags previous_state_flags) { /* FIXME * This is a hack to get around the optimizations done by the CSS engine. * * The CSS engine will notice that no CSS properties changed on the * widget itself when going from one state to another and not queue * a redraw. * And the reason for no properties changing will be that only the * checkmark itself changes, but that is hidden behind a * gtk_style_context_save()/_restore() pair, so it won't be caught. */ gtk_widget_queue_draw (widget); GTK_WIDGET_CLASS (gtk_check_button_parent_class)->state_flags_changed (widget, previous_state_flags); } static void gtk_check_button_class_init (GtkCheckButtonClass *class) { GtkWidgetClass *widget_class; widget_class = (GtkWidgetClass*) class; widget_class->get_preferred_width = gtk_check_button_get_preferred_width; widget_class->get_preferred_width_for_height = gtk_check_button_get_preferred_width_for_height; widget_class->get_preferred_height = gtk_check_button_get_preferred_height; widget_class->get_preferred_height_for_width = gtk_check_button_get_preferred_height_for_width; widget_class->get_preferred_height_and_baseline_for_width = gtk_check_button_get_preferred_height_and_baseline_for_width; widget_class->size_allocate = gtk_check_button_size_allocate; widget_class->draw = gtk_check_button_draw; widget_class->state_flags_changed = gtk_check_button_state_flags_changed; 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", P_("Indicator Size"), P_("Size of check or radio indicator"), 0, G_MAXINT, INDICATOR_SIZE, GTK_PARAM_READABLE)); gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("indicator-spacing", P_("Indicator Spacing"), P_("Spacing around check or radio indicator"), 0, G_MAXINT, INDICATOR_SPACING, GTK_PARAM_READABLE)); } static void draw_indicator_changed (GObject *object, GParamSpec *pspec, gpointer user_data) { GtkButton *button = GTK_BUTTON (object); G_GNUC_BEGIN_IGNORE_DEPRECATIONS 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); G_GNUC_END_IGNORE_DEPRECATIONS } static void gtk_check_button_init (GtkCheckButton *check_button) { 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 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) { 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 * * 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. * * Returns: a new #GtkCheckButton */ GtkWidget* gtk_check_button_new_with_mnemonic (const gchar *label) { return g_object_new (GTK_TYPE_CHECK_BUTTON, "label", label, "use-underline", TRUE, NULL); } /* This should only be called when toggle_button->draw_indicator * is true. */ static void gtk_check_button_paint (GtkWidget *widget, cairo_t *cr) { GtkCheckButton *check_button = GTK_CHECK_BUTTON (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; border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); gtk_widget_get_allocation (widget, &allocation); context = gtk_widget_get_style_context (widget); if (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, child_allocation.y - allocation.y, child_allocation.width, child_allocation.height); } else gtk_render_focus (context, cr, border_width, border_width, allocation.width - 2 * border_width, allocation.height - 2 * border_width); } } void _gtk_check_button_get_props (GtkCheckButton *check_button, gint *indicator_size, gint *indicator_spacing) { GtkWidget *widget = GTK_WIDGET (check_button); if (indicator_size) gtk_widget_style_get (widget, "indicator-size", indicator_size, NULL); if (indicator_spacing) gtk_widget_style_get (widget, "indicator-spacing", indicator_spacing, NULL); } static void get_padding_and_border (GtkWidget *widget, GtkBorder *border) { GtkStyleContext *context; GtkStateFlags state; GtkBorder tmp; context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); gtk_style_context_get_padding (context, state, border); gtk_style_context_get_border (context, state, &tmp); border->top += tmp.top; border->right += tmp.right; border->bottom += tmp.bottom; border->left += tmp.left; } static void gtk_check_button_get_full_border (GtkCheckButton *check_button, GtkBorder *border, gint *indicator) { int indicator_size, indicator_spacing, indicator_extra, border_width; GtkWidget *child; get_padding_and_border (GTK_WIDGET (check_button), border); border_width = gtk_container_get_border_width (GTK_CONTAINER (check_button)); gtk_widget_style_get (GTK_WIDGET (check_button), "indicator-size", &indicator_size, "indicator-spacing", &indicator_spacing, NULL); child = gtk_bin_get_child (GTK_BIN (check_button)); border->left += border_width; border->right += border_width; border->top += border_width; border->bottom += border_width; indicator_extra = indicator_size + 2 * indicator_spacing; if (child && gtk_widget_get_visible (child)) indicator_extra += indicator_spacing; if (gtk_widget_get_direction (GTK_WIDGET (check_button)) == GTK_TEXT_DIR_RTL) border->right += indicator_extra; else border->left += indicator_extra; if (indicator) *indicator = indicator_size + 2 * indicator_spacing; } static void gtk_check_button_get_preferred_width_for_height (GtkWidget *widget, gint height, gint *minimum, gint *natural) { GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (widget); if (gtk_toggle_button_get_mode (toggle_button)) { GtkWidget *child; GtkBorder border; gtk_check_button_get_full_border (GTK_CHECK_BUTTON (widget), &border, NULL); child = gtk_bin_get_child (GTK_BIN (widget)); if (child && gtk_widget_get_visible (child)) { if (height > -1) height -= border.top + border.bottom; _gtk_widget_get_preferred_size_for_size (child, GTK_ORIENTATION_HORIZONTAL, height, minimum, natural, NULL, NULL); } else { *minimum = 0; *natural = 0; } *minimum += border.left + border.right; *natural += border.left + border.right; } else GTK_WIDGET_CLASS (gtk_check_button_parent_class)->get_preferred_width (widget, minimum, natural); } static void gtk_check_button_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural) { gtk_check_button_get_preferred_width_for_height (widget, -1, minimum, natural); } static void gtk_check_button_get_preferred_height_and_baseline_for_width (GtkWidget *widget, gint width, gint *minimum, gint *natural, gint *minimum_baseline, gint *natural_baseline) { GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (widget); if (gtk_toggle_button_get_mode (toggle_button)) { GtkWidget *child; GtkBorder border; gint indicator; gtk_check_button_get_full_border (GTK_CHECK_BUTTON (widget), &border, &indicator); child = gtk_bin_get_child (GTK_BIN (widget)); if (child && gtk_widget_get_visible (child)) { gint child_min, child_nat; gint child_min_baseline = -1, child_nat_baseline = -1; if (width > -1) width -= border.left + border.right; gtk_widget_get_preferred_height_and_baseline_for_width (child, width, &child_min, &child_nat, &child_min_baseline, &child_nat_baseline); *minimum = MAX (indicator, child_min); *natural = MAX (indicator, child_nat); if (minimum_baseline && child_min_baseline >= 0) *minimum_baseline = child_min_baseline + border.top + (*minimum - child_min) / 2; if (natural_baseline && child_nat_baseline >= 0) *natural_baseline = child_nat_baseline + border.top + (*natural - child_nat) / 2; } else { *minimum = indicator; *natural = indicator; } *minimum += border.top + border.bottom; *natural += border.top + border.bottom; } else GTK_WIDGET_CLASS (gtk_check_button_parent_class)->get_preferred_height_and_baseline_for_width (widget, width, minimum, natural, minimum_baseline, natural_baseline); } static void gtk_check_button_get_preferred_height_for_width (GtkWidget *widget, gint width, gint *minimum, gint *natural) { gtk_check_button_get_preferred_height_and_baseline_for_width (widget, width, minimum, natural, NULL, NULL); } static void gtk_check_button_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural) { gtk_check_button_get_preferred_height_and_baseline_for_width (widget, -1, minimum, natural, NULL, NULL); } static void gtk_check_button_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { PangoContext *pango_context; PangoFontMetrics *metrics; GtkCheckButton *check_button; GtkToggleButton *toggle_button; GtkButton *button; GtkAllocation child_allocation; gint baseline; button = GTK_BUTTON (widget); check_button = GTK_CHECK_BUTTON (widget); toggle_button = GTK_TOGGLE_BUTTON (widget); if (gtk_toggle_button_get_mode (toggle_button)) { GtkWidget *child; 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); child = gtk_bin_get_child (GTK_BIN (button)); if (child && gtk_widget_get_visible (child)) { GtkBorder border; gtk_check_button_get_full_border (check_button, &border, NULL); child_allocation.x = allocation->x + border.left; child_allocation.y = allocation->y + border.top; child_allocation.width = allocation->width - border.left - border.right; child_allocation.height = allocation->height - border.top - border.bottom; baseline = gtk_widget_get_allocated_baseline (widget); if (baseline != -1) baseline -= border.top; gtk_widget_size_allocate_with_baseline (child, &child_allocation, baseline); } pango_context = gtk_widget_get_pango_context (widget); metrics = pango_context_get_metrics (pango_context, pango_context_get_font_description (pango_context), pango_context_get_language (pango_context)); button->priv->baseline_align = (double)pango_font_metrics_get_ascent (metrics) / (pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent (metrics)); pango_font_metrics_unref (metrics); } else GTK_WIDGET_CLASS (gtk_check_button_parent_class)->size_allocate (widget, allocation); } static gint gtk_check_button_draw (GtkWidget *widget, cairo_t *cr) { GtkToggleButton *toggle_button; GtkBin *bin; GtkWidget *child; toggle_button = GTK_TOGGLE_BUTTON (widget); bin = GTK_BIN (widget); if (gtk_toggle_button_get_mode (toggle_button)) { 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, cairo_t *cr) { GtkCheckButtonClass *class = GTK_CHECK_BUTTON_GET_CLASS (check_button); if (class->draw_indicator) class->draw_indicator (check_button, cr); } static void gtk_real_check_button_draw_indicator (GtkCheckButton *check_button, cairo_t *cr) { GtkWidget *widget; GtkButton *button; gint x, y; gint indicator_size; gint indicator_spacing; gint baseline; guint border_width; GtkAllocation allocation; GtkStyleContext *context; widget = GTK_WIDGET (check_button); button = GTK_BUTTON (check_button); gtk_widget_get_allocation (widget, &allocation); baseline = gtk_widget_get_allocated_baseline (widget); context = gtk_widget_get_style_context (widget); _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; if (baseline == -1) y = (allocation.height - indicator_size) / 2; else y = CLAMP (baseline - indicator_size * button->priv->baseline_align, 0, allocation.height - indicator_size); if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) x = allocation.width - (indicator_size + x); gtk_style_context_save (context); 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); }