X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkcheckbutton.c;h=d7df5a914e98f9c71ba306b063bf294af767b64a;hb=HEAD;hp=86bf09fef8680eb9c1270a5609302f0b3663393f;hpb=d9c92598612714683eab96fecf6e90a9531607e5;p=~andy%2Fgtk diff --git a/gtk/gtkcheckbutton.c b/gtk/gtkcheckbutton.c index 86bf09fef..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 . */ /* @@ -28,18 +26,38 @@ #include "gtkcheckbutton.h" +#include "gtkbuttonprivate.h" #include "gtklabel.h" #include "gtkprivate.h" #include "gtkintl.h" -#define INDICATOR_SIZE 13 +/** + * 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_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 gboolean gtk_check_button_draw (GtkWidget *widget, @@ -57,15 +75,18 @@ static void gtk_check_button_class_init (GtkCheckButtonClass *class) { GtkWidgetClass *widget_class; - + widget_class = (GtkWidgetClass*) class; - - 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->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", P_("Indicator Size"), @@ -84,15 +105,34 @@ gtk_check_button_class_init (GtkCheckButtonClass *class) 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_has_window (GTK_WIDGET (check_button), FALSE); gtk_widget_set_receives_default (GTK_WIDGET (check_button), FALSE); - GTK_TOGGLE_BUTTON (check_button)->draw_indicator = TRUE; - GTK_BUTTON (check_button)->depress_on_activate = 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) { @@ -100,6 +140,14 @@ gtk_check_button_new (void) } +/** + * 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) { @@ -109,13 +157,14 @@ gtk_check_button_new_with_label (const gchar *label) /** * 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. - **/ + * + * Returns: a new #GtkCheckButton + */ GtkWidget* gtk_check_button_new_with_mnemonic (const gchar *label) { @@ -134,50 +183,46 @@ gtk_check_button_paint (GtkWidget *widget, cairo_t *cr) { GtkCheckButton *check_button = GTK_CHECK_BUTTON (widget); - gint border_width; - gint interior_focus; - gint focus_width; - gint focus_pad; - - gtk_widget_style_get (widget, - "interior-focus", &interior_focus, - "focus-line-width", &focus_width, - "focus-padding", &focus_pad, - NULL); gtk_check_button_draw_indicator (check_button, cr); - border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); - if (gtk_widget_has_focus (widget)) + if (gtk_widget_has_visible_focus (widget)) { - GtkStateType state = gtk_widget_get_state (widget); - GtkStyle *style = gtk_widget_get_style (widget); GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget)); + GtkStyleContext *context; GtkAllocation allocation; + gint border_width; + gint interior_focus; + gint focus_width; + gint focus_pad; + + 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_paint_focus (style, cr, state, - widget, "checkbutton", - 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)); + 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_paint_focus (style, cr, state, - widget, "checkbutton", - border_width, - border_width, - allocation.width - 2 * border_width, - allocation.height - 2 * border_width); - } + gtk_render_focus (context, cr, + border_width, border_width, + allocation.width - 2 * border_width, + allocation.height - 2 * border_width); } } @@ -196,12 +241,59 @@ _gtk_check_button_get_props (GtkCheckButton *check_button, } 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 = 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; @@ -214,34 +306,33 @@ gtk_check_button_size_request (GtkWidget *widget, 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); - - requisition->width = border_width * 2; - requisition->height = border_width * 2; + "focus-line-width", &focus_width, + "focus-padding", &focus_pad, + NULL); + + *minimum = border_width * 2; + *natural = border_width * 2; _gtk_check_button_get_props (GTK_CHECK_BUTTON (widget), - &indicator_size, &indicator_spacing); - + &indicator_size, &indicator_spacing); + child = gtk_bin_get_child (GTK_BIN (widget)); if (child && gtk_widget_get_visible (child)) - { - GtkRequisition child_requisition; + { + gint child_min, child_nat; - gtk_widget_get_preferred_size (child, &child_requisition, NULL); + gtk_widget_get_preferred_height (child, &child_min, &child_nat); + + *minimum += child_min; + *natural += child_nat; + } - requisition->width += child_requisition.width + indicator_spacing; - requisition->height += child_requisition.height; - } - - requisition->width += (indicator_size + indicator_spacing * 2 + 2 * (focus_width + focus_pad)); - temp = indicator_size + indicator_spacing * 2; - requisition->height = MAX (requisition->height, temp) + 2 * (focus_width + focus_pad); + *minimum = MAX (*minimum, temp) + 2 * (focus_width + focus_pad); + *natural = MAX (*natural, temp) + 2 * (focus_width + focus_pad); } else - GTK_WIDGET_CLASS (gtk_check_button_parent_class)->size_request (widget, requisition); + GTK_WIDGET_CLASS (gtk_check_button_parent_class)->get_preferred_height (widget, minimum, natural); } static void @@ -257,7 +348,7 @@ gtk_check_button_size_allocate (GtkWidget *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; @@ -274,26 +365,20 @@ gtk_check_button_size_allocate (GtkWidget *widget, gtk_widget_set_allocation (widget, allocation); if (gtk_widget_get_realized (widget)) - gdk_window_move_resize (button->event_window, + 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)) { - GtkRequisition child_requisition; guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); - gtk_widget_get_preferred_size (child, &child_requisition, NULL); - - child_allocation.width = MIN (child_requisition.width, - allocation->width - - ((border_width + focus_width + focus_pad) * 2 - + indicator_size + indicator_spacing * 3)); + 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 = MIN (child_requisition.height, - allocation->height - (border_width + focus_width + focus_pad) * 2); + 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 + @@ -321,8 +406,8 @@ gtk_check_button_draw (GtkWidget *widget, toggle_button = GTK_TOGGLE_BUTTON (widget); bin = GTK_BIN (widget); - - if (toggle_button->draw_indicator) + + if (gtk_toggle_button_get_mode (toggle_button)) { gtk_check_button_paint (widget, cr); @@ -357,8 +442,7 @@ gtk_real_check_button_draw_indicator (GtkCheckButton *check_button, GtkWidget *child; GtkButton *button; GtkToggleButton *toggle_button; - GtkStateType state_type; - GtkShadowType shadow_type; + GtkStateFlags state = 0; gint x, y; gint indicator_size; gint indicator_spacing; @@ -367,16 +451,15 @@ gtk_real_check_button_draw_indicator (GtkCheckButton *check_button, guint border_width; gboolean interior_focus; GtkAllocation allocation; - GtkStyle *style; - GdkWindow *window; + GtkStyleContext *context; widget = GTK_WIDGET (check_button); button = GTK_BUTTON (check_button); toggle_button = GTK_TOGGLE_BUTTON (check_button); gtk_widget_get_allocation (widget, &allocation); - style = gtk_widget_get_style (widget); - window = gtk_widget_get_window (widget); + context = gtk_widget_get_style_context (widget); + state = gtk_widget_get_state_flags (widget); gtk_widget_style_get (widget, "interior-focus", &interior_focus, @@ -395,38 +478,39 @@ gtk_real_check_button_draw_indicator (GtkCheckButton *check_button, 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 (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; - + 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); - if (gtk_widget_get_state (widget) == GTK_STATE_PRELIGHT) - { + gtk_style_context_save (context); + gtk_style_context_set_state (context, state); - gtk_paint_flat_box (style, cr, GTK_STATE_PRELIGHT, - GTK_SHADOW_ETCHED_OUT, - widget, "checkbutton", - border_width, border_width, - allocation.width - (2 * border_width), - allocation.height - (2 * border_width)); - } + 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_paint_check (style, cr, - state_type, shadow_type, - widget, "checkbutton", - x, y, indicator_size, indicator_size); + gtk_style_context_restore (context); }