X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkbutton.c;h=3ac36a71b8d37ddeccc5ee2b95a641466345d1eb;hb=1074aa0c49f647ed4b2a969618051c59da5aad01;hp=c3838d9253ffecde1b3349e09fafcdf929e2d825;hpb=c7514e8f0d19a833257497caff413bb4dfae6eb4;p=~andy%2Fgtk diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c index c3838d925..3ac36a71b 100644 --- a/gtk/gtkbutton.c +++ b/gtk/gtkbutton.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 . */ /* @@ -26,15 +24,15 @@ /** * SECTION:gtkbutton - * @Short_description: A widget that creates a signal when clicked on + * @Short_description: A widget that emits a signal when clicked on * @Title: GtkButton * - * The #GtkButton widget is generally used to attach a function to that is + * The #GtkButton widget is generally used to trigger a callback function that is * called when the button is pressed. The various signals and how to use them * are outlined below. * - * The #GtkButton widget can hold any valid child widget. That is it can hold - * most any other standard #GtkWidget. The most commonly used child is the + * The #GtkButton widget can hold any valid child widget. That is, it can hold + * almost any other standard #GtkWidget. The most commonly used child is the * #GtkLabel. */ @@ -49,8 +47,7 @@ #include "gtkmain.h" #include "gtkmarshalers.h" #include "gtkimage.h" -#include "gtkhbox.h" -#include "gtkvbox.h" +#include "gtkbox.h" #include "gtkstock.h" #include "gtkiconfactory.h" #include "gtkactivatable.h" @@ -58,11 +55,12 @@ #include "gtktypebuiltins.h" #include "gtkprivate.h" #include "gtkintl.h" - +#include "a11y/gtkbuttonaccessible.h" +#include "gtkapplicationprivate.h" +#include "gtkactionhelper.h" static const GtkBorder default_default_border = { 1, 1, 1, 1 }; static const GtkBorder default_default_outside_border = { 0, 0, 0, 0 }; -static const GtkBorder default_inner_border = { 1, 1, 1, 1 }; /* Time out before giving up on getting a key release when animating * the close button. @@ -91,6 +89,9 @@ enum { PROP_XALIGN, PROP_YALIGN, PROP_IMAGE_POSITION, + PROP_ACTION_NAME, + PROP_ACTION_TARGET, + PROP_ALWAYS_SHOW_IMAGE, /* activatable properties */ PROP_ACTIVATABLE_RELATED_ACTION, @@ -122,6 +123,8 @@ static gint gtk_button_button_press (GtkWidget * widget, GdkEventButton * event); static gint gtk_button_button_release (GtkWidget * widget, GdkEventButton * event); +static gboolean gtk_button_touch (GtkWidget *widget, + GdkEventTouch *event); static gint gtk_button_grab_broken (GtkWidget * widget, GdkEventGrabBroken * event); static gint gtk_button_key_release (GtkWidget * widget, GdkEventKey * event); @@ -149,7 +152,7 @@ static void gtk_button_state_changed (GtkWidget *widget, static void gtk_button_grab_notify (GtkWidget *widget, gboolean was_grabbed); - +static void gtk_button_actionable_iface_init (GtkActionableInterface *iface); static void gtk_button_activatable_interface_init(GtkActivatableIface *iface); static void gtk_button_update (GtkActivatable *activatable, GtkAction *action, @@ -171,6 +174,7 @@ static void gtk_button_get_preferred_height (GtkWidget *widget, static guint button_signals[LAST_SIGNAL] = { 0 }; G_DEFINE_TYPE_WITH_CODE (GtkButton, gtk_button, GTK_TYPE_BIN, + G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIONABLE, gtk_button_actionable_iface_init) G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE, gtk_button_activatable_interface_init)) @@ -203,6 +207,7 @@ gtk_button_class_init (GtkButtonClass *klass) widget_class->draw = gtk_button_draw; widget_class->button_press_event = gtk_button_button_press; widget_class->button_release_event = gtk_button_button_release; + widget_class->touch_event = gtk_button_touch; widget_class->grab_broken_event = gtk_button_grab_broken; widget_class->key_release_event = gtk_button_key_release; widget_class->enter_notify_event = gtk_button_enter_notify; @@ -331,6 +336,28 @@ gtk_button_class_init (GtkButtonClass *klass) GTK_POS_LEFT, GTK_PARAM_READWRITE)); + /** + * GtkButton:always-show-image: + * + * If %TRUE, the button will ignore the #GtkSettings:gtk-button-images + * setting and always show the image, if available. + * + * Use this property if the button would be useless or hard to use + * without the image. + * + * Since: 3.6 + */ + g_object_class_install_property (gobject_class, + PROP_ALWAYS_SHOW_IMAGE, + g_param_spec_boolean ("always-show-image", + P_("Always show image"), + P_("Whether the image will always be shown"), + FALSE, + GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_override_property (gobject_class, PROP_ACTION_NAME, "action-name"); + g_object_class_override_property (gobject_class, PROP_ACTION_TARGET, "action-target"); + g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_RELATED_ACTION, "related-action"); g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance"); @@ -503,6 +530,9 @@ gtk_button_class_init (GtkButtonClass *klass) * Sets the border between the button edges and child. * * Since: 2.10 + * + * Deprecated: 3.4: Use the standard border and padding CSS properties; + * the value of this style property is ignored. */ gtk_widget_class_install_style_property (widget_class, g_param_spec_boxed ("inner-border", @@ -528,6 +558,8 @@ gtk_button_class_init (GtkButtonClass *klass) GTK_PARAM_READABLE)); g_type_class_add_private (gobject_class, sizeof (GtkButtonPrivate)); + + gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_BUTTON_ACCESSIBLE); } static void @@ -662,6 +694,8 @@ gtk_button_dispose (GObject *object) GtkButton *button = GTK_BUTTON (object); GtkButtonPrivate *priv = button->priv; + g_clear_object (&priv->action_helper); + if (priv->action) { gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (button), NULL); @@ -670,6 +704,36 @@ gtk_button_dispose (GObject *object) G_OBJECT_CLASS (gtk_button_parent_class)->dispose (object); } +static void +gtk_button_set_action_name (GtkActionable *actionable, + const gchar *action_name) +{ + GtkButton *button = GTK_BUTTON (actionable); + + g_return_if_fail (button->priv->action == NULL); + + if (!button->priv->action_helper) + button->priv->action_helper = gtk_action_helper_new (actionable); + + g_signal_handlers_disconnect_by_func (button, gtk_real_button_clicked, NULL); + if (action_name) + g_signal_connect_after (button, "clicked", G_CALLBACK (gtk_real_button_clicked), NULL); + + gtk_action_helper_set_action_name (button->priv->action_helper, action_name); +} + +static void +gtk_button_set_action_target_value (GtkActionable *actionable, + GVariant *action_target) +{ + GtkButton *button = GTK_BUTTON (actionable); + + if (!button->priv->action_helper) + button->priv->action_helper = gtk_action_helper_new (actionable); + + gtk_action_helper_set_action_target_value (button->priv->action_helper, action_target); +} + static void gtk_button_set_property (GObject *object, guint prop_id, @@ -687,6 +751,9 @@ gtk_button_set_property (GObject *object, case PROP_IMAGE: gtk_button_set_image (button, (GtkWidget *) g_value_get_object (value)); break; + case PROP_ALWAYS_SHOW_IMAGE: + gtk_button_set_always_show_image (button, g_value_get_boolean (value)); + break; case PROP_RELIEF: gtk_button_set_relief (button, g_value_get_enum (value)); break; @@ -714,6 +781,12 @@ gtk_button_set_property (GObject *object, case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE: gtk_button_set_use_action_appearance (button, g_value_get_boolean (value)); break; + case PROP_ACTION_NAME: + gtk_button_set_action_name (GTK_ACTIONABLE (button), g_value_get_string (value)); + break; + case PROP_ACTION_TARGET: + gtk_button_set_action_target_value (GTK_ACTIONABLE (button), g_value_get_variant (value)); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -737,6 +810,9 @@ gtk_button_get_property (GObject *object, case PROP_IMAGE: g_value_set_object (value, (GObject *)priv->image); break; + case PROP_ALWAYS_SHOW_IMAGE: + g_value_set_boolean (value, gtk_button_get_always_show_image (button)); + break; case PROP_RELIEF: g_value_set_enum (value, priv->relief); break; @@ -764,12 +840,43 @@ gtk_button_get_property (GObject *object, case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE: g_value_set_boolean (value, priv->use_action_appearance); break; + case PROP_ACTION_NAME: + g_value_set_string (value, gtk_action_helper_get_action_name (priv->action_helper)); + break; + case PROP_ACTION_TARGET: + g_value_set_variant (value, gtk_action_helper_get_action_target_value (priv->action_helper)); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } +static const gchar * +gtk_button_get_action_name (GtkActionable *actionable) +{ + GtkButton *button = GTK_BUTTON (actionable); + + return gtk_action_helper_get_action_name (button->priv->action_helper); +} + +static GVariant * +gtk_button_get_action_target_value (GtkActionable *actionable) +{ + GtkButton *button = GTK_BUTTON (actionable); + + return gtk_action_helper_get_action_target_value (button->priv->action_helper); +} + +static void +gtk_button_actionable_iface_init (GtkActionableInterface *iface) +{ + iface->get_action_name = gtk_button_get_action_name; + iface->set_action_name = gtk_button_set_action_name; + iface->get_action_target_value = gtk_button_get_action_target_value; + iface->set_action_target_value = gtk_button_set_action_target_value; +} + static void gtk_button_activatable_interface_init (GtkActivatableIface *iface) { @@ -896,6 +1003,9 @@ gtk_button_sync_action_properties (GtkActivatable *activatable, activatable_update_gicon (GTK_BUTTON (activatable), action); activatable_update_icon_name (GTK_BUTTON (activatable), action); } + + gtk_button_set_always_show_image (button, + gtk_action_get_always_show_image (action)); } static void @@ -904,6 +1014,8 @@ gtk_button_set_related_action (GtkButton *button, { GtkButtonPrivate *priv = button->priv; + g_return_if_fail (gtk_action_helper_get_action_name (button->priv->action_helper) == NULL); + if (priv->action == action) return; @@ -955,7 +1067,7 @@ show_image (GtkButton *button) GtkButtonPrivate *priv = button->priv; gboolean show; - if (priv->label_text) + if (priv->label_text && !priv->always_show_image) { GtkSettings *settings; @@ -968,6 +1080,7 @@ show_image (GtkButton *button) return show; } + static void gtk_button_construct_child (GtkButton *button) { @@ -1133,14 +1246,15 @@ gtk_button_new_from_stock (const gchar *stock_id) * gtk_button_new_with_mnemonic: * @label: The text of the button, with an underscore in front of the * mnemonic character - * @returns: a new #GtkButton * * Creates a new #GtkButton containing a label. * If characters in @label are preceded by an underscore, they are underlined. - * If you need a literal underscore character in a label, use '__' (two - * underscores). The first underlined character represents a keyboard + * If you need a literal underscore character in a label, use '__' (two + * underscores). The first underlined character represents a keyboard * accelerator called a mnemonic. * Pressing Alt and that key activates the button. + * + * Returns: a new #GtkButton **/ GtkWidget* gtk_button_new_with_mnemonic (const gchar *label) @@ -1293,9 +1407,10 @@ gtk_button_realize (GtkWidget *widget) attributes.wclass = GDK_INPUT_ONLY; attributes.event_mask = gtk_widget_get_events (widget); attributes.event_mask |= (GDK_BUTTON_PRESS_MASK | - GDK_BUTTON_RELEASE_MASK | - GDK_ENTER_NOTIFY_MASK | - GDK_LEAVE_NOTIFY_MASK); + GDK_BUTTON_RELEASE_MASK | + GDK_TOUCH_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK); attributes_mask = GDK_WA_X | GDK_WA_Y; @@ -1305,7 +1420,7 @@ gtk_button_realize (GtkWidget *widget) priv->event_window = gdk_window_new (window, &attributes, attributes_mask); - gdk_window_set_user_data (priv->event_window, button); + gtk_widget_register_window (widget, priv->event_window); } static void @@ -1319,7 +1434,7 @@ gtk_button_unrealize (GtkWidget *widget) if (priv->event_window) { - gdk_window_set_user_data (priv->event_window, NULL); + gtk_widget_unregister_window (widget, priv->event_window); gdk_window_destroy (priv->event_window); priv->event_window = NULL; } @@ -1346,7 +1461,10 @@ gtk_button_unmap (GtkWidget *widget) GtkButtonPrivate *priv = button->priv; if (priv->event_window) - gdk_window_hide (priv->event_window); + { + gdk_window_hide (priv->event_window); + priv->in_button = FALSE; + } GTK_WIDGET_CLASS (gtk_button_parent_class)->unmap (widget); } @@ -1397,13 +1515,16 @@ static void gtk_button_get_props (GtkButton *button, GtkBorder *default_border, GtkBorder *default_outside_border, - GtkBorder *inner_border, + GtkBorder *padding, + GtkBorder *border, gboolean *interior_focus) { GtkStyleContext *context; + GtkStateFlags state; GtkBorder *tmp_border; context = gtk_widget_get_style_context (GTK_WIDGET (button)); + state = gtk_style_context_get_state (context); if (default_border) { @@ -1435,27 +1556,18 @@ gtk_button_get_props (GtkButton *button, *default_outside_border = default_default_outside_border; } - if (inner_border) - { - gtk_style_context_get_style (context, - "inner-border", &tmp_border, - NULL); - - if (tmp_border) - { - *inner_border = *tmp_border; - gtk_border_free (tmp_border); - } - else - *inner_border = default_inner_border; - } - if (interior_focus) { gtk_style_context_get_style (context, "interior-focus", interior_focus, NULL); } + + if (padding) + gtk_style_context_get_padding (context, state, padding); + + if (border) + gtk_style_context_get_border (context, state, border); } static void @@ -1466,27 +1578,22 @@ gtk_button_size_allocate (GtkWidget *widget, GtkButtonPrivate *priv = button->priv; GtkAllocation child_allocation; GtkStyleContext *context; - GtkStateFlags state; GtkWidget *child; GtkBorder default_border; - GtkBorder inner_border; - GtkBorder *border; + GtkBorder padding; + GtkBorder border; gint focus_width; gint focus_pad; context = gtk_widget_get_style_context (widget); - state = gtk_widget_get_state_flags (widget); - gtk_button_get_props (button, &default_border, NULL, &inner_border, NULL); + gtk_button_get_props (button, &default_border, NULL, + &padding, &border, NULL); gtk_style_context_get_style (context, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); - gtk_style_context_get (context, state, - "border-width", &border, - NULL); - gtk_widget_set_allocation (widget, allocation); if (gtk_widget_get_realized (widget)) @@ -1499,20 +1606,18 @@ gtk_button_size_allocate (GtkWidget *widget, child = gtk_bin_get_child (GTK_BIN (button)); if (child && gtk_widget_get_visible (child)) { - child_allocation.x = allocation->x + inner_border.left + border->left; - child_allocation.y = allocation->y + inner_border.top + border->top; + child_allocation.x = allocation->x + padding.left + border.left; + child_allocation.y = allocation->y + padding.top + border.top; child_allocation.width = allocation->width - - (border->left + border->right) - - inner_border.left - - inner_border.right; + (padding.left + padding.right) - + (border.left + border.right); child_allocation.height = allocation->height - - (border->top + border->bottom) - - inner_border.top - - inner_border.bottom; + (padding.top + padding.bottom) - + (border.top + border.bottom); if (gtk_widget_get_can_default (GTK_WIDGET (button))) { @@ -1548,19 +1653,14 @@ gtk_button_size_allocate (GtkWidget *widget, gtk_widget_size_allocate (child, &child_allocation); } - - gtk_border_free (border); } -void -_gtk_button_paint (GtkButton *button, - cairo_t *cr, - int width, - int height, - GtkStateFlags state) +static gboolean +gtk_button_draw (GtkWidget *widget, + cairo_t *cr) { + GtkButton *button = GTK_BUTTON (widget); GtkButtonPrivate *priv = button->priv; - GtkWidget *widget; gint x, y; GtkBorder default_border; GtkBorder default_outside_border; @@ -1569,14 +1669,14 @@ _gtk_button_paint (GtkButton *button, gint focus_pad; GtkAllocation allocation; GtkStyleContext *context; + GtkStateFlags state; + gboolean draw_focus; + gint width, height; - widget = GTK_WIDGET (button); context = gtk_widget_get_style_context (widget); + state = gtk_style_context_get_state (context); - gtk_style_context_save (context); - gtk_style_context_set_state (context, state); - - gtk_button_get_props (button, &default_border, &default_outside_border, NULL, &interior_focus); + gtk_button_get_props (button, &default_border, &default_outside_border, NULL, NULL, &interior_focus); gtk_style_context_get_style (context, "focus-line-width", &focus_width, "focus-padding", &focus_pad, @@ -1586,6 +1686,8 @@ _gtk_button_paint (GtkButton *button, x = 0; y = 0; + width = allocation.width; + height = allocation.height; if (gtk_widget_has_default (widget) && priv->relief == GTK_RELIEF_NORMAL) @@ -1594,8 +1696,6 @@ _gtk_button_paint (GtkButton *button, y += default_border.top; width -= default_border.left + default_border.right; height -= default_border.top + default_border.bottom; - - gtk_style_context_add_class (context, GTK_STYLE_CLASS_DEFAULT); } else if (gtk_widget_get_can_default (widget)) { @@ -1604,8 +1704,11 @@ _gtk_button_paint (GtkButton *button, width -= default_outside_border.left + default_outside_border.right; height -= default_outside_border.top + default_outside_border.bottom; } - - if (!interior_focus && gtk_widget_has_focus (widget)) + + draw_focus = gtk_widget_has_visible_focus (widget); + + + if (!interior_focus && draw_focus) { x += focus_width + focus_pad; y += focus_width + focus_pad; @@ -1622,29 +1725,26 @@ _gtk_button_paint (GtkButton *button, x, y, width, height); } - if (gtk_widget_has_focus (widget)) + if (draw_focus) { gint child_displacement_x; gint child_displacement_y; gboolean displace_focus; - GtkBorder *border; + GtkBorder border; gtk_style_context_get_style (context, "child-displacement-y", &child_displacement_y, "child-displacement-x", &child_displacement_x, "displace-focus", &displace_focus, NULL); - - gtk_style_context_get (context, state, - "border-width", &border, - NULL); + gtk_style_context_get_border (context, state, &border); if (interior_focus) { - x += border->left + focus_pad; - y += border->top + focus_pad; - width -= (2 * focus_pad) + border->left + border->right; - height -= (2 * focus_pad) + border->top + border->bottom; + x += border.left + focus_pad; + y += border.top + focus_pad; + width -= (2 * focus_pad) + border.left + border.right; + height -= (2 * focus_pad) + border.top + border.bottom; } else { @@ -1660,26 +1760,9 @@ _gtk_button_paint (GtkButton *button, y += child_displacement_y; } - gtk_render_focus (context, cr, - x, y, width, height); - - gtk_border_free (border); + gtk_render_focus (context, cr, x, y, width, height); } - gtk_style_context_restore (context); -} - -static gboolean -gtk_button_draw (GtkWidget *widget, - cairo_t *cr) -{ - GtkButton *button = GTK_BUTTON (widget); - - _gtk_button_paint (button, cr, - gtk_widget_get_allocated_width (widget), - gtk_widget_get_allocated_height (widget), - gtk_widget_get_state_flags (widget)); - GTK_WIDGET_CLASS (gtk_button_parent_class)->draw (widget, cr); return FALSE; @@ -1700,8 +1783,8 @@ gtk_button_button_press (GtkWidget *widget, if (priv->focus_on_click && !gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); - if (event->button == 1) - gtk_button_pressed (button); + if (event->button == GDK_BUTTON_PRIMARY) + g_signal_emit (button, button_signals[PRESSED], 0); } return TRUE; @@ -1713,10 +1796,32 @@ gtk_button_button_release (GtkWidget *widget, { GtkButton *button; - if (event->button == 1) + if (event->button == GDK_BUTTON_PRIMARY) { button = GTK_BUTTON (widget); - gtk_button_released (button); + g_signal_emit (button, button_signals[RELEASED], 0); + } + + return TRUE; +} + +static gboolean +gtk_button_touch (GtkWidget *widget, + GdkEventTouch *event) +{ + GtkButton *button = GTK_BUTTON (widget); + GtkButtonPrivate *priv = button->priv; + + if (event->type == GDK_TOUCH_BEGIN) + { + if (priv->focus_on_click && !gtk_widget_has_focus (widget)) + gtk_widget_grab_focus (widget); + + g_signal_emit (button, button_signals[PRESSED], 0); + } + else if (event->type == GDK_TOUCH_END) + { + g_signal_emit (button, button_signals[RELEASED], 0); } return TRUE; @@ -1735,7 +1840,7 @@ gtk_button_grab_broken (GtkWidget *widget, { save_in = priv->in_button; priv->in_button = FALSE; - gtk_button_released (button); + g_signal_emit (button, button_signals[RELEASED], 0); if (save_in != priv->in_button) { priv->in_button = save_in; @@ -1775,7 +1880,7 @@ gtk_button_enter_notify (GtkWidget *widget, (event->detail != GDK_NOTIFY_INFERIOR)) { priv->in_button = TRUE; - gtk_button_enter (button); + g_signal_emit (button, button_signals[ENTER], 0); } return FALSE; @@ -1793,7 +1898,7 @@ gtk_button_leave_notify (GtkWidget *widget, (gtk_widget_get_sensitive (widget))) { priv->in_button = FALSE; - gtk_button_leave (button); + g_signal_emit (button, button_signals[LEAVE], 0); } return FALSE; @@ -1811,6 +1916,40 @@ gtk_real_button_pressed (GtkButton *button) gtk_button_update_state (button); } +static gboolean +touch_release_in_button (GtkButton *button) +{ + GtkButtonPrivate *priv; + gint width, height; + GdkEvent *event; + gdouble x, y; + + priv = button->priv; + event = gtk_get_current_event (); + + if (!event) + return FALSE; + + if (event->type != GDK_TOUCH_END || + event->touch.window != priv->event_window) + { + gdk_event_free (event); + return FALSE; + } + + gdk_event_get_coords (event, &x, &y); + width = gdk_window_get_width (priv->event_window); + height = gdk_window_get_height (priv->event_window); + + gdk_event_free (event); + + if (x >= 0 && x <= width && + y >= 0 && y <= height) + return TRUE; + + return FALSE; +} + static void gtk_real_button_released (GtkButton *button) { @@ -1823,7 +1962,8 @@ gtk_real_button_released (GtkButton *button) if (priv->activate_timeout) return; - if (priv->in_button) + if (priv->in_button || + touch_release_in_button (button)) gtk_button_clicked (button); gtk_button_update_state (button); @@ -1835,6 +1975,9 @@ gtk_real_button_clicked (GtkButton *button) { GtkButtonPrivate *priv = button->priv; + if (priv->action_helper) + gtk_action_helper_activate (priv->action_helper); + if (priv->action) gtk_action_activate (priv->action); } @@ -1871,7 +2014,7 @@ gtk_real_button_activate (GtkButton *button) { if (gdk_device_grab (device, priv->event_window, GDK_OWNERSHIP_WINDOW, TRUE, - GDK_KEY_PRESS | GDK_KEY_RELEASE, + GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, NULL, time) == GDK_GRAB_SUCCESS) { gtk_device_grab_add (widget, device, TRUE); @@ -1924,40 +2067,35 @@ gtk_button_get_size (GtkWidget *widget, { GtkButton *button = GTK_BUTTON (widget); GtkStyleContext *context; - GtkStateFlags state; GtkWidget *child; GtkBorder default_border; - GtkBorder inner_border; - GtkBorder *border; + GtkBorder padding; + GtkBorder border; gint focus_width; gint focus_pad; gint minimum, natural; context = gtk_widget_get_style_context (widget); - state = gtk_widget_get_state_flags (widget); - gtk_button_get_props (button, &default_border, NULL, &inner_border, NULL); + gtk_button_get_props (button, &default_border, NULL, + &padding, &border, NULL); gtk_style_context_get_style (context, "focus-line-width", &focus_width, "focus-padding", &focus_pad, NULL); - gtk_style_context_get (context, state, - "border-width", &border, - NULL); - if (orientation == GTK_ORIENTATION_HORIZONTAL) { - minimum = (border->left + border->right + - inner_border.left + inner_border.right); + minimum = padding.left + padding.right + + border.left + border.right; if (gtk_widget_get_can_default (GTK_WIDGET (widget))) minimum += default_border.left + default_border.right; } else { - minimum = (border->top + border->bottom + - inner_border.top + inner_border.bottom); + minimum = padding.top + padding.bottom + + border.top + border.bottom; if (gtk_widget_get_can_default (GTK_WIDGET (widget))) minimum += default_border.top + default_border.bottom; @@ -1985,8 +2123,6 @@ gtk_button_get_size (GtkWidget *widget, if (natural_size) *natural_size = natural; - - gtk_border_free (border); } static void @@ -2049,7 +2185,7 @@ gtk_button_set_label (GtkButton *button, * Return value: The text of the label widget. This string is owned * by the widget and must not be modified or freed. **/ -G_CONST_RETURN gchar * +const gchar * gtk_button_get_label (GtkButton *button) { g_return_val_if_fail (GTK_IS_BUTTON (button), NULL); @@ -2312,7 +2448,7 @@ gtk_button_update_state (GtkButton *button) if (priv->in_button) new_state |= GTK_STATE_FLAG_PRELIGHT; - if (priv->button_down || depressed) + if (depressed) new_state |= GTK_STATE_FLAG_ACTIVE; _gtk_button_set_depressed (button, depressed); @@ -2545,6 +2681,63 @@ gtk_button_get_image_position (GtkButton *button) return button->priv->image_position; } +/** + * gtk_button_set_always_show_image: + * @button: a #GtkButton + * @always_show: %TRUE if the menuitem should always show the image + * + * If %TRUE, the button will ignore the #GtkSettings:gtk-button-images + * setting and always show the image, if available. + * + * Use this property if the button would be useless or hard to use + * without the image. + * + * Since: 3.6 + */ +void +gtk_button_set_always_show_image (GtkButton *button, + gboolean always_show) +{ + GtkButtonPrivate *priv; + + g_return_if_fail (GTK_IS_BUTTON (button)); + + priv = button->priv; + + if (priv->always_show_image != always_show) + { + priv->always_show_image = always_show; + + if (priv->image) + { + if (show_image (button)) + gtk_widget_show (priv->image); + else + gtk_widget_hide (priv->image); + } + + g_object_notify (G_OBJECT (button), "always-show-image"); + } +} + +/** + * gtk_button_get_always_show_image: + * @button: a #GtkButton + * + * Returns whether the button will ignore the #GtkSettings:gtk-button-images + * setting and always show the image, if available. + * + * Returns: %TRUE if the button will always show the image + * + * Since: 3.6 + */ +gboolean +gtk_button_get_always_show_image (GtkButton *button) +{ + g_return_val_if_fail (GTK_IS_BUTTON (button), FALSE); + + return button->priv->always_show_image; +} /** * gtk_button_get_event_window: