X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkbutton.c;h=3ac36a71b8d37ddeccc5ee2b95a641466345d1eb;hb=1074aa0c49f647ed4b2a969618051c59da5aad01;hp=cbfbdcb072c8a91d9c3f42efcf3a4bfdde7a012b;hpb=9c0ef02ea56acce7232c91994ea4bce1d288893f;p=~andy%2Fgtk diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c index cbfbdcb07..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,19 +47,20 @@ #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" #include "gtksizerequest.h" +#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. @@ -90,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, @@ -121,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); @@ -148,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, @@ -170,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)) @@ -202,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; @@ -265,7 +271,7 @@ gtk_button_class_init (GtkButtonClass *klass) * GtkButton:xalign: * * If the child of the button is a #GtkMisc or #GtkAlignment, this property - * can be used to control it's horizontal alignment. 0.0 is left aligned, + * can be used to control its horizontal alignment. 0.0 is left aligned, * 1.0 is right aligned. * * Since: 2.4 @@ -284,7 +290,7 @@ gtk_button_class_init (GtkButtonClass *klass) * GtkButton:yalign: * * If the child of the button is a #GtkMisc or #GtkAlignment, this property - * can be used to control it's vertical alignment. 0.0 is top aligned, + * can be used to control its vertical alignment. 0.0 is top aligned, * 1.0 is bottom aligned. * * Since: 2.4 @@ -300,7 +306,7 @@ gtk_button_class_init (GtkButtonClass *klass) GTK_PARAM_READWRITE)); /** - * GtkButton::image: + * GtkButton:image: * * The child widget to appear next to the button text. * @@ -330,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"); @@ -502,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", @@ -527,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 @@ -661,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); @@ -669,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, @@ -686,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; @@ -713,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; @@ -736,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; @@ -763,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) { @@ -895,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 @@ -903,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; @@ -954,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; @@ -967,10 +1080,12 @@ show_image (GtkButton *button) return show; } + static void gtk_button_construct_child (GtkButton *button) { GtkButtonPrivate *priv = button->priv; + GtkStyleContext *context; GtkStockItem item; GtkWidget *child; GtkWidget *label; @@ -986,9 +1101,11 @@ gtk_button_construct_child (GtkButton *button) if (!priv->label_text && !priv->image) return; - gtk_widget_style_get (GTK_WIDGET (button), - "image-spacing", &image_spacing, - NULL); + context = gtk_widget_get_style_context (GTK_WIDGET (button)); + + gtk_style_context_get_style (context, + "image-spacing", &image_spacing, + NULL); if (priv->image && !priv->image_is_stock) { @@ -1129,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) @@ -1289,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; @@ -1301,9 +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_style_attach (widget); + gtk_widget_register_window (widget, priv->event_window); } static void @@ -1317,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; } @@ -1344,13 +1461,17 @@ 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); } static void -gtk_button_update_image_spacing (GtkButton *button) +gtk_button_update_image_spacing (GtkButton *button, + GtkStyleContext *context) { GtkButtonPrivate *priv = button->priv; GtkWidget *child; @@ -1369,34 +1490,47 @@ gtk_button_update_image_spacing (GtkButton *button) child = gtk_bin_get_child (GTK_BIN (child)); if (GTK_IS_BOX (child)) { - gtk_widget_style_get (GTK_WIDGET (button), - "image-spacing", &spacing, - NULL); + gtk_style_context_get_style (context, + "image-spacing", &spacing, + NULL); gtk_box_set_spacing (GTK_BOX (child), spacing); } - } + } } static void gtk_button_style_updated (GtkWidget *widget) { - gtk_button_update_image_spacing (GTK_BUTTON (widget)); + GtkStyleContext *context; + + GTK_WIDGET_CLASS (gtk_button_parent_class)->style_updated (widget); + + context = gtk_widget_get_style_context (widget); + + gtk_button_update_image_spacing (GTK_BUTTON (widget), context); } 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) { - GtkWidget *widget = GTK_WIDGET (button); + 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) { - gtk_widget_style_get (widget, "default-border", &tmp_border, NULL); + gtk_style_context_get_style (context, + "default-border", &tmp_border, + NULL); if (tmp_border) { @@ -1409,7 +1543,9 @@ gtk_button_get_props (GtkButton *button, if (default_outside_border) { - gtk_widget_style_get (widget, "default-outside-border", &tmp_border, NULL); + gtk_style_context_get_style (context, + "default-outside-border", &tmp_border, + NULL); if (tmp_border) { @@ -1420,21 +1556,18 @@ gtk_button_get_props (GtkButton *button, *default_outside_border = default_default_outside_border; } - if (inner_border) + if (interior_focus) { - gtk_widget_style_get (widget, "inner-border", &tmp_border, NULL); - - if (tmp_border) - { - *inner_border = *tmp_border; - gtk_border_free (tmp_border); - } - else - *inner_border = default_inner_border; + gtk_style_context_get_style (context, + "interior-focus", interior_focus, + NULL); } - if (interior_focus) - gtk_widget_style_get (widget, "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 @@ -1445,30 +1578,21 @@ gtk_button_size_allocate (GtkWidget *widget, GtkButtonPrivate *priv = button->priv; GtkAllocation child_allocation; GtkStyleContext *context; - GtkStateFlags state; GtkWidget *child; - - gint xthickness, ythickness; GtkBorder default_border; - GtkBorder inner_border; - gint focus_width, border_width; + 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_style_context_get (context, state, - "border-width", &border_width, - NULL); - - xthickness = border_width; - ythickness = border_width; - - gtk_button_get_props (button, &default_border, NULL, &inner_border, NULL); - gtk_widget_style_get (GTK_WIDGET (widget), - "focus-line-width", &focus_width, - "focus-padding", &focus_pad, - 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_widget_set_allocation (widget, allocation); @@ -1482,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 + xthickness; - child_allocation.y = allocation->y + inner_border.top + ythickness; + child_allocation.x = allocation->x + padding.left + border.left; + child_allocation.y = allocation->y + padding.top + border.top; child_allocation.width = allocation->width - - xthickness * 2 - - inner_border.left - - inner_border.right; + (padding.left + padding.right) - + (border.left + border.right); child_allocation.height = allocation->height - - ythickness * 2 - - inner_border.top - - inner_border.bottom; + (padding.top + padding.bottom) - + (border.top + border.bottom); if (gtk_widget_get_can_default (GTK_WIDGET (button))) { @@ -1517,11 +1639,11 @@ gtk_button_size_allocate (GtkWidget *widget, { gint child_displacement_x; gint child_displacement_y; - - gtk_widget_style_get (widget, - "child-displacement-x", &child_displacement_x, - "child-displacement-y", &child_displacement_y, - NULL); + + gtk_style_context_get_style (context, + "child-displacement-x", &child_displacement_x, + "child-displacement-y", &child_displacement_y, + NULL); child_allocation.x += child_displacement_x; child_allocation.y += child_displacement_y; } @@ -1533,18 +1655,12 @@ gtk_button_size_allocate (GtkWidget *widget, } } -void -_gtk_button_paint (GtkButton *button, - cairo_t *cr, - int width, - int height, - GtkStateType state_type, - GtkShadowType shadow_type, - const gchar *main_detail, - const gchar *default_detail) +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; @@ -1552,24 +1668,26 @@ _gtk_button_paint (GtkButton *button, gint focus_width; gint focus_pad; GtkAllocation allocation; - GdkWindow *window; 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_button_get_props (button, &default_border, &default_outside_border, NULL, &interior_focus); - gtk_widget_style_get (widget, - "focus-line-width", &focus_width, - "focus-padding", &focus_pad, - NULL); + 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, + NULL); gtk_widget_get_allocation (widget, &allocation); - context = gtk_widget_get_style_context (widget); - window = gtk_widget_get_window (widget); x = 0; y = 0; + width = allocation.width; + height = allocation.height; if (gtk_widget_has_default (widget) && priv->relief == GTK_RELIEF_NORMAL) @@ -1578,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)) { @@ -1588,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; @@ -1597,9 +1716,6 @@ _gtk_button_paint (GtkButton *button, height -= 2 * (focus_width + focus_pad); } - state = gtk_widget_get_state_flags (widget); - gtk_style_context_set_state (context, state); - if (priv->relief != GTK_RELIEF_NONE || priv->depressed || state & GTK_STATE_FLAG_PRELIGHT) { @@ -1609,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; - gint border_width; - - gtk_widget_style_get (widget, - "child-displacement-y", &child_displacement_y, - "child-displacement-x", &child_displacement_x, - "displace-focus", &displace_focus, - NULL); + GtkBorder border; - gtk_style_context_get (context, state, - "border-width", &border_width, - NULL); + 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_border (context, state, &border); if (interior_focus) { - x += border_width + focus_pad; - y += border_width + focus_pad; - width -= 2 * (border_width + focus_pad); - height -= 2 * (border_width + focus_pad); + 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 { @@ -1647,24 +1760,8 @@ _gtk_button_paint (GtkButton *button, y += child_displacement_y; } - gtk_render_focus (context, cr, - x, y, width, height); + gtk_render_focus (context, cr, x, y, width, height); } -} - -static gboolean -gtk_button_draw (GtkWidget *widget, - cairo_t *cr) -{ - GtkButton *button = GTK_BUTTON (widget); - GtkButtonPrivate *priv = button->priv; - - _gtk_button_paint (button, cr, - gtk_widget_get_allocated_width (widget), - gtk_widget_get_allocated_height (widget), - gtk_widget_get_state (widget), - priv->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT, - "button", "buttondefault"); GTK_WIDGET_CLASS (gtk_button_parent_class)->draw (widget, cr); @@ -1686,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; @@ -1699,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; @@ -1721,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; @@ -1761,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; @@ -1779,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; @@ -1797,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) { @@ -1809,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); @@ -1821,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); } @@ -1846,20 +2003,24 @@ gtk_real_button_activate (GtkButton *button) if (device && gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD) device = gdk_device_get_associated_device (device); - g_return_if_fail (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD); - if (gtk_widget_get_realized (widget) && !priv->activate_timeout) { time = gtk_get_current_event_time (); - if (gdk_device_grab (device, priv->event_window, - GDK_OWNERSHIP_WINDOW, TRUE, - GDK_KEY_PRESS | GDK_KEY_RELEASE, - NULL, time) == GDK_GRAB_SUCCESS) - { - gtk_device_grab_add (widget, device, TRUE); - priv->grab_keyboard = device; - priv->grab_time = time; + /* bgo#626336 - Only grab if we have a device (from an event), not if we + * were activated programmatically when no event is available. + */ + if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) + { + if (gdk_device_grab (device, priv->event_window, + GDK_OWNERSHIP_WINDOW, TRUE, + GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, + NULL, time) == GDK_GRAB_SUCCESS) + { + gtk_device_grab_add (widget, device, TRUE); + priv->grab_keyboard = device; + priv->grab_time = time; + } } priv->activate_timeout = gdk_threads_add_timeout (ACTIVATE_TIMEOUT, @@ -1908,37 +2069,33 @@ gtk_button_get_size (GtkWidget *widget, GtkStyleContext *context; GtkWidget *child; GtkBorder default_border; - GtkBorder inner_border; - GtkStateFlags state; - gint focus_width, border_width; + GtkBorder padding; + GtkBorder border; + gint focus_width; gint focus_pad; gint minimum, natural; - gtk_button_get_props (button, &default_border, NULL, &inner_border, NULL); - gtk_widget_style_get (GTK_WIDGET (widget), - "focus-line-width", &focus_width, - "focus-padding", &focus_pad, - NULL); - - context = gtk_widget_get_style_context (GTK_WIDGET (widget)); - state = gtk_widget_get_state_flags (GTK_WIDGET (widget)); + context = gtk_widget_get_style_context (widget); - gtk_style_context_get (context, state, - "border-width", &border_width, - 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); if (orientation == GTK_ORIENTATION_HORIZONTAL) { - minimum = (border_width * 2 + - 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_width * 2 + - 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; @@ -2028,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); @@ -2223,8 +2380,8 @@ gtk_button_set_alignment (GtkButton *button, /** * gtk_button_get_alignment: * @button: a #GtkButton - * @xalign: return location for horizontal alignment - * @yalign: return location for vertical alignment + * @xalign: (out): return location for horizontal alignment + * @yalign: (out): return location for vertical alignment * * Gets the alignment of the child in the button. * @@ -2277,7 +2434,7 @@ static void gtk_button_update_state (GtkButton *button) { GtkButtonPrivate *priv = button->priv; - GtkStateFlags new_state = 0; + GtkStateFlags new_state; gboolean depressed; if (priv->activate_timeout) @@ -2285,10 +2442,13 @@ gtk_button_update_state (GtkButton *button) else depressed = priv->in_button && priv->button_down; + new_state = gtk_widget_get_state_flags (GTK_WIDGET (button)) & + ~(GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_ACTIVE); + 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); @@ -2521,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: