gtk2/gtk/gtkgesturelongpress.c

376 lines
12 KiB
C
Raw Normal View History

/* GTK - The GIMP Toolkit
* Copyright (C) 2012, One Laptop Per Child.
* Copyright (C) 2014, Red Hat, Inc.
*
* 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 <http://www.gnu.org/licenses/>.
*
* Author(s): Carlos Garnacho <carlosg@gnome.org>
*/
2014-04-09 16:28:12 +00:00
/**
* SECTION:gtkgesturelongpress
2014-05-20 00:45:42 +00:00
* @Short_description: "Press and Hold" gesture
2014-04-09 16:28:12 +00:00
* @Title: GtkGestureLongPress
*
* #GtkGestureLongPress is a #GtkGesture implementation able to recognize
2014-04-10 11:43:41 +00:00
* long presses, triggering the #GtkGestureLongPress::pressed after the
2014-04-09 16:28:12 +00:00
* timeout is exceeded.
*
* If the touchpoint is lifted before the timeout passes, or if it drifts
* too far of the initial press point, the #GtkGestureLongPress::cancelled
* signal will be emitted.
*/
#include "config.h"
#include "gtkgesturelongpress.h"
#include "gtkgesturelongpressprivate.h"
#include "gtkgestureprivate.h"
#include "gtkmarshalers.h"
#include "gtkdragsource.h"
#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
typedef struct _GtkGestureLongPressPrivate GtkGestureLongPressPrivate;
enum {
PRESSED,
CANCELLED,
N_SIGNALS
};
enum {
PROP_DELAY_FACTOR = 1
};
struct _GtkGestureLongPressPrivate
{
gdouble initial_x;
gdouble initial_y;
gdouble delay_factor;
guint timeout_id;
guint delay;
guint cancelled : 1;
guint triggered : 1;
};
static guint signals[N_SIGNALS] = { 0 };
G_DEFINE_TYPE_WITH_PRIVATE (GtkGestureLongPress, gtk_gesture_long_press, GTK_TYPE_GESTURE_SINGLE)
static void
gtk_gesture_long_press_init (GtkGestureLongPress *gesture)
{
GtkGestureLongPressPrivate *priv;
priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (gesture));
priv->delay_factor = 1.0;
}
static gboolean
gtk_gesture_long_press_check (GtkGesture *gesture)
{
GtkGestureLongPressPrivate *priv;
priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (gesture));
if (priv->cancelled)
return FALSE;
return GTK_GESTURE_CLASS (gtk_gesture_long_press_parent_class)->check (gesture);
}
static gboolean
_gtk_gesture_long_press_timeout (gpointer user_data)
{
GtkGestureLongPress *gesture = user_data;
GtkGestureLongPressPrivate *priv;
GdkEventSequence *sequence;
gdouble x, y;
priv = gtk_gesture_long_press_get_instance_private (gesture);
sequence = gtk_gesture_get_last_updated_sequence (GTK_GESTURE (gesture));
gtk_gesture_get_point (GTK_GESTURE (gesture), sequence, &x, &y);
priv->timeout_id = 0;
priv->triggered = TRUE;
g_signal_emit (gesture, signals[PRESSED], 0, x, y);
return G_SOURCE_REMOVE;
}
static void
gtk_gesture_long_press_begin (GtkGesture *gesture,
GdkEventSequence *sequence)
{
GtkGestureLongPressPrivate *priv;
GdkEvent *event;
GdkEventType event_type;
GtkWidget *widget;
gint delay;
priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (gesture));
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
event = gtk_gesture_get_last_event (gesture, sequence);
if (!event)
return;
event_type = gdk_event_get_event_type (event);
if (event_type != GDK_BUTTON_PRESS &&
event_type != GDK_TOUCH_BEGIN)
return;
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
g_object_get (gtk_widget_get_settings (widget),
"gtk-long-press-time", &delay,
NULL);
delay = (gint)(priv->delay_factor * delay);
gtk_gesture_get_point (gesture, sequence,
&priv->initial_x, &priv->initial_y);
priv->timeout_id = g_timeout_add (delay, _gtk_gesture_long_press_timeout, gesture);
g_source_set_name_by_id (priv->timeout_id, "[gtk] _gtk_gesture_long_press_timeout");
}
static void
gtk_gesture_long_press_update (GtkGesture *gesture,
GdkEventSequence *sequence)
{
GtkGestureLongPressPrivate *priv;
GtkWidget *widget;
gdouble x, y;
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (gesture));
gtk_gesture_get_point (gesture, sequence, &x, &y);
if (gtk_drag_check_threshold (widget, priv->initial_x, priv->initial_y, x, y))
{
if (priv->timeout_id)
{
g_source_remove (priv->timeout_id);
priv->timeout_id = 0;
2014-04-08 19:10:43 +00:00
g_signal_emit (gesture, signals[CANCELLED], 0);
}
priv->cancelled = TRUE;
_gtk_gesture_check (gesture);
}
}
static void
gtk_gesture_long_press_end (GtkGesture *gesture,
GdkEventSequence *sequence)
{
GtkGestureLongPressPrivate *priv;
priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (gesture));
if (priv->timeout_id)
{
g_source_remove (priv->timeout_id);
priv->timeout_id = 0;
2014-04-08 19:10:43 +00:00
g_signal_emit (gesture, signals[CANCELLED], 0);
}
priv->cancelled = priv->triggered = FALSE;
}
static void
gtk_gesture_long_press_cancel (GtkGesture *gesture,
GdkEventSequence *sequence)
{
gtk_gesture_long_press_end (gesture, sequence);
GTK_GESTURE_CLASS (gtk_gesture_long_press_parent_class)->cancel (gesture, sequence);
}
static void
gtk_gesture_long_press_sequence_state_changed (GtkGesture *gesture,
GdkEventSequence *sequence,
GtkEventSequenceState state)
{
if (state == GTK_EVENT_SEQUENCE_DENIED)
2014-04-08 19:10:43 +00:00
gtk_gesture_long_press_end (gesture, sequence);
}
static void
gtk_gesture_long_press_finalize (GObject *object)
{
GtkGestureLongPressPrivate *priv;
priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (object));
if (priv->timeout_id)
g_source_remove (priv->timeout_id);
G_OBJECT_CLASS (gtk_gesture_long_press_parent_class)->finalize (object);
}
static void
gtk_gesture_long_press_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
switch (property_id)
{
case PROP_DELAY_FACTOR:
g_value_set_double (value, gtk_gesture_long_press_get_delay_factor (GTK_GESTURE_LONG_PRESS (object)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_gesture_long_press_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
switch (property_id)
{
case PROP_DELAY_FACTOR:
gtk_gesture_long_press_set_delay_factor (GTK_GESTURE_LONG_PRESS (object),
g_value_get_double (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_gesture_long_press_class_init (GtkGestureLongPressClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkGestureClass *gesture_class = GTK_GESTURE_CLASS (klass);
object_class->finalize = gtk_gesture_long_press_finalize;
object_class->get_property = gtk_gesture_long_press_get_property;
object_class->set_property = gtk_gesture_long_press_set_property;
gesture_class->check = gtk_gesture_long_press_check;
gesture_class->begin = gtk_gesture_long_press_begin;
gesture_class->update = gtk_gesture_long_press_update;
gesture_class->end = gtk_gesture_long_press_end;
gesture_class->cancel = gtk_gesture_long_press_cancel;
gesture_class->sequence_state_changed = gtk_gesture_long_press_sequence_state_changed;
g_object_class_install_property (object_class,
PROP_DELAY_FACTOR,
g_param_spec_double ("delay-factor",
P_("Delay factor"),
P_("Factor by which to modify the default timeout"),
0.5, 2.0, 1.0,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY));
2014-04-09 16:28:12 +00:00
/**
2014-04-10 11:43:41 +00:00
* GtkGestureLongPress::pressed:
2014-04-09 16:28:12 +00:00
* @gesture: the object which received the signal
* @x: the X coordinate where the press happened, relative to the widget allocation
* @y: the Y coordinate where the press happened, relative to the widget allocation
*
* This signal is emitted whenever a press goes unmoved/unreleased longer than
* what the GTK+ defaults tell.
*/
signals[PRESSED] =
g_signal_new (I_("pressed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkGestureLongPressClass, pressed),
NULL, NULL,
_gtk_marshal_VOID__DOUBLE_DOUBLE,
G_TYPE_NONE, 2, G_TYPE_DOUBLE, G_TYPE_DOUBLE);
g_signal_set_va_marshaller (signals[PRESSED],
G_TYPE_FROM_CLASS (klass),
_gtk_marshal_VOID__DOUBLE_DOUBLEv);
2014-04-09 16:28:12 +00:00
/**
2014-04-10 11:43:41 +00:00
* GtkGestureLongPress::cancelled:
2014-04-09 16:28:12 +00:00
* @gesture: the object which received the signal
*
* This signal is emitted whenever a press moved too far, or was released
* before #GtkGestureLongPress::pressed happened.
2014-04-09 16:28:12 +00:00
*/
signals[CANCELLED] =
g_signal_new (I_("cancelled"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkGestureLongPressClass, cancelled),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
}
/**
* gtk_gesture_long_press_new:
*
2014-05-20 02:16:03 +00:00
* Returns a newly created #GtkGesture that recognizes long presses.
*
* Returns: a newly created #GtkGestureLongPress
**/
GtkGesture *
gtk_gesture_long_press_new (void)
{
return g_object_new (GTK_TYPE_GESTURE_LONG_PRESS,
NULL);
}
/**
2020-04-20 02:50:35 +00:00
* gtk_gesture_long_press_set_delay_factor:
* @gesture: A #GtkGestureLongPress
* @delay_factor: The delay factor to apply
*
* Applies the given delay factor. The default long press time will be
2020-04-20 02:50:35 +00:00
* multiplied by this value. Valid values are in the range [0.5..2.0].
*/
void
gtk_gesture_long_press_set_delay_factor (GtkGestureLongPress *gesture,
double delay_factor)
{
GtkGestureLongPressPrivate *priv = gtk_gesture_long_press_get_instance_private (gesture);
g_return_if_fail (GTK_IS_GESTURE_LONG_PRESS (gesture));
g_return_if_fail (delay_factor >= 0.5);
g_return_if_fail (delay_factor <= 2.0);
priv->delay_factor = delay_factor;
g_object_notify (G_OBJECT (gesture), "delay-factor");
}
/**
2020-04-20 02:50:35 +00:00
* gtk_gesture_long_press_get_delay_factor:
* @gesture: A #GtkGestureLongPress
*
* Returns the delay factor as set by gtk_gesture_long_press_set_delay_factor().
2020-04-20 02:50:35 +00:00
*
* Returns: the delay factor
*/
double
gtk_gesture_long_press_get_delay_factor (GtkGestureLongPress *gesture)
{
GtkGestureLongPressPrivate *priv = gtk_gesture_long_press_get_instance_private (gesture);
g_return_val_if_fail (GTK_IS_GESTURE_LONG_PRESS (gesture), 0);
return priv->delay_factor;
}