brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ddda4aec18
mutter/clutter/clutter-click-action.c

803 lines
22 KiB
C
Raw Normal View History

action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* 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:
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
/**
* SECTION:clutter-click-action
* @Title: ClutterClickAction
* @Short_Description: Action for clickable actors
*
* #ClutterClickAction is a sub-class of #ClutterAction that implements
* the logic for clickable actors, by using the low level events of
* #ClutterActor, such as #ClutterActor::button-press-event and
* #ClutterActor::button-release-event, to synthesize the high level
* #ClutterClickAction::clicked signal.
*
* To use #ClutterClickAction you just need to apply it to a #ClutterActor
* using clutter_actor_add_action() and connect to the
* #ClutterClickAction::clicked signal:
*
* |[
* ClutterAction *action = clutter_click_action_new ();
*
* clutter_actor_add_action (actor, action);
*
* g_signal_connect (action, "clicked", G_CALLBACK (on_clicked), NULL);
* ]|
*
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
* #ClutterClickAction also supports long press gestures: a long press is
* activated if the pointer remains pressed within a certain threshold (as
* defined by the #ClutterClickAction:long-press-threshold property) for a
* minimum amount of time (as the defined by the
* #ClutterClickAction:long-press-duration property).
* The #ClutterClickAction::long-press signal is emitted multiple times,
* using different #ClutterLongPressState values; to handle long presses
* you should connect to the #ClutterClickAction::long-press signal and
* handle the different states:
*
* |[
* static gboolean
* on_long_press (ClutterClickAction *action,
* ClutterActor *actor,
* ClutterLongPressState state)
* {
* switch (state)
* {
* case CLUTTER_LONG_PRESS_QUERY:
* /&ast; return TRUE if the actor should support long press
* &ast; gestures, and FALSE otherwise; this state will be
* &ast; emitted on button presses
* &ast;/
* return TRUE;
*
* case CLUTTER_LONG_PRESS_ACTIVATE:
* /&ast; this state is emitted if the minimum duration has
* &ast; been reached without the gesture being cancelled.
* &ast; the return value is not used
* &ast;/
* return TRUE;
*
* case CLUTTER_LONG_PRESS_CANCEL:
* /&ast; this state is emitted if the long press was cancelled;
* &ast; for instance, the pointer went outside the actor or the
* &ast; allowed threshold, or the button was released before
* &ast; the minimum duration was reached. the return value is
* &ast; not used
* &ast;/
* return FALSE;
* }
* }
* ]|
*
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
* #ClutterClickAction is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "clutter-click-action.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
struct _ClutterClickActionPrivate
{
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
ClutterActor *stage;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
guint event_id;
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
guint capture_id;
guint long_press_id;
gint long_press_threshold;
gint long_press_duration;
gint drag_threshold;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
guint press_button;
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
gint press_device_id;
ClutterEventSequence *press_sequence;
click-action: add API to get modifier type This is to allow implementing modified click such as ctrl+click, shift+click, and so on. http://bugzilla.clutter-project.org/show_bug.cgi?id=2520
2011-01-17 00:38:04 +00:00
ClutterModifierType modifier_state;
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
gfloat press_x;
gfloat press_y;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
guint is_held : 1;
guint is_pressed : 1;
};
enum
{
PROP_0,
PROP_HELD,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
PROP_PRESSED,
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
PROP_LONG_PRESS_THRESHOLD,
PROP_LONG_PRESS_DURATION,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
PROP_LAST
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
};
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
static GParamSpec *obj_props[PROP_LAST] = { NULL, };
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
enum
{
CLICKED,
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
LONG_PRESS,
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
LAST_SIGNAL
};
static guint click_signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE (ClutterClickAction, clutter_click_action, CLUTTER_TYPE_ACTION);
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
/* forward declaration */
static gboolean on_captured_event (ClutterActor *stage,
ClutterEvent *event,
ClutterClickAction *action);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
static inline void
click_action_set_pressed (ClutterClickAction *action,
gboolean is_pressed)
{
ClutterClickActionPrivate *priv = action->priv;
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
is_pressed = !!is_pressed;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
if (priv->is_pressed == is_pressed)
return;
priv->is_pressed = is_pressed;
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (action), obj_props[PROP_PRESSED]);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
}
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
static inline void
click_action_set_held (ClutterClickAction *action,
gboolean is_held)
{
ClutterClickActionPrivate *priv = action->priv;
is_held = !!is_held;
if (priv->is_held == is_held)
return;
priv->is_held = is_held;
g_object_notify_by_pspec (G_OBJECT (action), obj_props[PROP_HELD]);
}
static gboolean
click_action_emit_long_press (gpointer data)
{
ClutterClickAction *action = data;
ClutterClickActionPrivate *priv = action->priv;
ClutterActor *actor;
gboolean result;
priv->long_press_id = 0;
actor = clutter_actor_meta_get_actor (data);
g_signal_emit (action, click_signals[LONG_PRESS], 0,
actor,
CLUTTER_LONG_PRESS_ACTIVATE,
&result);
if (priv->capture_id != 0)
{
g_signal_handler_disconnect (priv->stage, priv->capture_id);
priv->capture_id = 0;
}
click_action_set_pressed (action, FALSE);
click_action_set_held (action, FALSE);
return FALSE;
}
static inline void
click_action_query_long_press (ClutterClickAction *action)
{
ClutterClickActionPrivate *priv = action->priv;
ClutterActor *actor;
gboolean result = FALSE;
gint timeout;
if (priv->long_press_duration < 0)
{
ClutterSettings *settings = clutter_settings_get_default ();
g_object_get (settings,
"long-press-duration", &timeout,
NULL);
}
else
timeout = priv->long_press_duration;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (action));
g_signal_emit (action, click_signals[LONG_PRESS], 0,
actor,
CLUTTER_LONG_PRESS_QUERY,
&result);
if (result)
{
priv->long_press_id =
clutter_threads_add_timeout (timeout,
click_action_emit_long_press,
action);
}
}
static inline void
click_action_cancel_long_press (ClutterClickAction *action)
{
ClutterClickActionPrivate *priv = action->priv;
if (priv->long_press_id != 0)
{
ClutterActor *actor;
gboolean result;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (action));
g_source_remove (priv->long_press_id);
priv->long_press_id = 0;
g_signal_emit (action, click_signals[LONG_PRESS], 0,
actor,
CLUTTER_LONG_PRESS_CANCEL,
&result);
}
}
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
static gboolean
on_event (ClutterActor *actor,
ClutterEvent *event,
ClutterClickAction *action)
{
ClutterClickActionPrivate *priv = action->priv;
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
gboolean has_button = TRUE;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (action)))
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_PROPAGATE;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
switch (clutter_event_type (event))
{
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
case CLUTTER_TOUCH_BEGIN:
has_button = FALSE;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
case CLUTTER_BUTTON_PRESS:
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
if (has_button && clutter_event_get_click_count (event) != 1)
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_PROPAGATE;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
if (priv->is_held)
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_STOP;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
click-action: Use clutter_actor_contains() Instead of an internal copy.
2010-06-11 14:23:46 +00:00
if (!clutter_actor_contains (actor, clutter_event_get_source (event)))
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_PROPAGATE;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
priv->press_button = has_button ? clutter_event_get_button (event) : 0;
priv->press_device_id = clutter_event_get_device_id (event);
priv->press_sequence = clutter_event_get_event_sequence (event);
click-action: add API to get modifier type This is to allow implementing modified click such as ctrl+click, shift+click, and so on. http://bugzilla.clutter-project.org/show_bug.cgi?id=2520
2011-01-17 00:38:04 +00:00
priv->modifier_state = clutter_event_get_state (event);
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
clutter_event_get_coords (event, &priv->press_x, &priv->press_y);
if (priv->long_press_threshold < 0)
{
ClutterSettings *settings = clutter_settings_get_default ();
g_object_get (settings,
"dnd-drag-threshold", &priv->drag_threshold,
NULL);
}
else
priv->drag_threshold = priv->long_press_threshold;
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
if (priv->stage == NULL)
priv->stage = clutter_actor_get_stage (actor);
priv->capture_id = g_signal_connect_after (priv->stage, "captured-event",
G_CALLBACK (on_captured_event),
action);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
click_action_set_pressed (action, TRUE);
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
click_action_set_held (action, TRUE);
click_action_query_long_press (action);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
break;
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
case CLUTTER_ENTER:
click_action_set_pressed (action, priv->is_held);
break;
case CLUTTER_LEAVE:
click_action_set_pressed (action, priv->is_held);
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
click_action_cancel_long_press (action);
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
break;
default:
break;
}
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_PROPAGATE;
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
}
static gboolean
on_captured_event (ClutterActor *stage,
ClutterEvent *event,
ClutterClickAction *action)
{
ClutterClickActionPrivate *priv = action->priv;
ClutterActor *actor;
click-action: add API to get modifier type This is to allow implementing modified click such as ctrl+click, shift+click, and so on. http://bugzilla.clutter-project.org/show_bug.cgi?id=2520
2011-01-17 00:38:04 +00:00
ClutterModifierType modifier_state;
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
gboolean has_button = TRUE;
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (action));
switch (clutter_event_type (event))
{
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
case CLUTTER_TOUCH_END:
has_button = FALSE;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
case CLUTTER_BUTTON_RELEASE:
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
if (!priv->is_held)
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_STOP;
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
if ((has_button && clutter_event_get_button (event) != priv->press_button) ||
(has_button && clutter_event_get_click_count (event) != 1) ||
clutter_event_get_device_id (event) != priv->press_device_id ||
clutter_event_get_event_sequence (event) != priv->press_sequence)
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_PROPAGATE;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
click_action_set_held (action, FALSE);
click_action_cancel_long_press (action);
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
/* disconnect the capture */
if (priv->capture_id != 0)
{
g_signal_handler_disconnect (priv->stage, priv->capture_id);
priv->capture_id = 0;
}
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
if (priv->long_press_id != 0)
{
g_source_remove (priv->long_press_id);
priv->long_press_id = 0;
}
click-action: Use clutter_actor_contains() Instead of an internal copy.
2010-06-11 14:23:46 +00:00
if (!clutter_actor_contains (actor, clutter_event_get_source (event)))
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_PROPAGATE;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
click-action: add API to get modifier type This is to allow implementing modified click such as ctrl+click, shift+click, and so on. http://bugzilla.clutter-project.org/show_bug.cgi?id=2520
2011-01-17 00:38:04 +00:00
/* exclude any button-mask so that we can compare
* the press and release states properly */
modifier_state = clutter_event_get_state (event) &
~(CLUTTER_BUTTON1_MASK |
CLUTTER_BUTTON2_MASK |
CLUTTER_BUTTON3_MASK |
CLUTTER_BUTTON4_MASK |
CLUTTER_BUTTON5_MASK);
/* if press and release states don't match we
* simply ignore modifier keys. i.e. modifier keys
* are expected to be pressed throughout the whole
* click */
if (modifier_state != priv->modifier_state)
priv->modifier_state = 0;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
click_action_set_pressed (action, FALSE);
g_signal_emit (action, click_signals[CLICKED], 0, actor);
break;
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
case CLUTTER_MOTION:
click-action: add touch event support Allow for touch events to trigger the "clicked" event on ClickAction without introducing API changes. https://bugzilla.gnome.org/show_bug.cgi?id=683936
2012-09-13 09:20:00 +00:00
case CLUTTER_TOUCH_UPDATE:
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
{
gfloat motion_x, motion_y;
gfloat delta_x, delta_y;
if (!priv->is_held)
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_PROPAGATE;
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
clutter_event_get_coords (event, &motion_x, &motion_y);
delta_x = ABS (motion_x - priv->press_x);
delta_y = ABS (motion_y - priv->press_y);
if (delta_x > priv->drag_threshold ||
delta_y > priv->drag_threshold)
click_action_cancel_long_press (action);
}
break;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
default:
break;
}
click-action: Use the new symbolic event propagation macros
2012-01-12 10:27:17 +00:00
return CLUTTER_EVENT_STOP;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
}
static void
clutter_click_action_set_actor (ClutterActorMeta *meta,
ClutterActor *actor)
{
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
ClutterClickAction *action = CLUTTER_CLICK_ACTION (meta);
ClutterClickActionPrivate *priv = action->priv;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
if (priv->event_id != 0)
{
ClutterActor *old_actor = clutter_actor_meta_get_actor (meta);
click-action: Be resilient against NULL pointers Do not try to disconnect signal handlers from NULL pointers.
2012-01-12 10:26:47 +00:00
if (old_actor != NULL)
g_signal_handler_disconnect (old_actor, priv->event_id);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
priv->event_id = 0;
}
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
if (priv->capture_id != 0)
{
click-action: Be resilient against NULL pointers Do not try to disconnect signal handlers from NULL pointers.
2012-01-12 10:26:47 +00:00
if (priv->stage != NULL)
g_signal_handler_disconnect (priv->stage, priv->capture_id);
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
priv->capture_id = 0;
priv->stage = NULL;
}
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
if (priv->long_press_id != 0)
{
g_source_remove (priv->long_press_id);
priv->long_press_id = 0;
}
click_action_set_pressed (action, FALSE);
click_action_set_held (action, FALSE);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
if (actor != NULL)
priv->event_id = g_signal_connect (actor, "event",
G_CALLBACK (on_event),
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
action);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
CLUTTER_ACTOR_META_CLASS (clutter_click_action_parent_class)->set_actor (meta, actor);
}
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
static void
clutter_click_action_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
switch (prop_id)
{
case PROP_LONG_PRESS_DURATION:
priv->long_press_duration = g_value_get_int (value);
break;
case PROP_LONG_PRESS_THRESHOLD:
priv->long_press_threshold = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
static void
clutter_click_action_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
switch (prop_id)
{
case PROP_HELD:
g_value_set_boolean (value, priv->is_held);
break;
case PROP_PRESSED:
g_value_set_boolean (value, priv->is_pressed);
break;
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
case PROP_LONG_PRESS_DURATION:
g_value_set_int (value, priv->long_press_duration);
break;
case PROP_LONG_PRESS_THRESHOLD:
g_value_set_int (value, priv->long_press_threshold);
break;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_click_action_class_init (ClutterClickActionClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
g_type_class_add_private (klass, sizeof (ClutterClickActionPrivate));
meta_class->set_actor = clutter_click_action_set_actor;
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
gobject_class->set_property = clutter_click_action_set_property;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
gobject_class->get_property = clutter_click_action_get_property;
/**
* ClutterClickAction:pressed:
*
* Whether the clickable actor should be in "pressed" state
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
obj_props[PROP_PRESSED] =
g_param_spec_boolean ("pressed",
P_("Pressed"),
P_("Whether the clickable should be in pressed state"),
FALSE,
CLUTTER_PARAM_READABLE);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
/**
* ClutterClickAction:held:
*
* Whether the clickable actor has the pointer grabbed
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
obj_props[PROP_HELD] =
g_param_spec_boolean ("held",
P_("Held"),
P_("Whether the clickable has a grab"),
FALSE,
CLUTTER_PARAM_READABLE);
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
/**
* ClutterClickAction:long-press-duration:
*
* The minimum duration of a press for it to be recognized as a long
* press gesture, in milliseconds.
*
* A value of -1 will make the #ClutterClickAction use the value of
* the #ClutterSettings:long-press-duration property.
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
*/
obj_props[PROP_LONG_PRESS_DURATION] =
g_param_spec_int ("long-press-duration",
P_("Long Press Duration"),
P_("The minimum duration of a long press to recognize the gesture"),
-1, G_MAXINT,
-1,
CLUTTER_PARAM_READWRITE);
/**
* ClutterClickAction:long-press-threshold:
*
* The maximum allowed distance that can be covered (on both axes) before
* a long press gesture is cancelled, in pixels.
*
* A value of -1 will make the #ClutterClickAction use the value of
* the #ClutterSettings:dnd-drag-threshold property.
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
*/
obj_props[PROP_LONG_PRESS_THRESHOLD] =
g_param_spec_int ("long-press-threshold",
P_("Long Press Threshold"),
P_("The maximum threshold before a long press is cancelled"),
-1, G_MAXINT,
-1,
CLUTTER_PARAM_READWRITE);
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_class_install_properties (gobject_class,
PROP_LAST,
obj_props);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
/**
* ClutterClickAction::clicked:
* @action: the #ClutterClickAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
*
* The ::clicked signal is emitted when the #ClutterActor to which
* a #ClutterClickAction has been applied should respond to a
* pointer button press and release events
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
*/
click_signals[CLICKED] =
g_signal_new (I_("clicked"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterClickActionClass, clicked),
NULL, NULL,
Hide the marshallers The marshallers we use for the signals are declared in a private header, and it stands to reason that they should also be hidden in the shared object by using the common '_' prefix. We are also using some direct g_cclosure_marshal_* symbol from GLib, instead of consistently use the clutter_marshal_* symbol.
2010-06-11 14:49:46 +00:00
_clutter_marshal_VOID__OBJECT,
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
/**
* ClutterClickAction::long-press:
* @action: the #ClutterClickAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @state: the long press state
*
* The ::long-press signal is emitted during the long press gesture
* handling.
*
* This signal can be emitted multiple times with different states.
*
* The %CLUTTER_LONG_PRESS_QUERY state will be emitted on button presses,
* and its return value will determine whether the long press handling
* should be initiated. If the signal handlers will return %TRUE, the
* %CLUTTER_LONG_PRESS_QUERY state will be followed either by a signal
* emission with the %CLUTTER_LONG_PRESS_ACTIVATE state if the long press
* constraints were respected, or by a signal emission with the
* %CLUTTER_LONG_PRESS_CANCEL state if the long press was cancelled.
*
* It is possible to forcibly cancel a long press detection using
* clutter_click_action_release().
*
* Return value: Only the %CLUTTER_LONG_PRESS_QUERY state uses the
* returned value of the handler; other states will ignore it
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
*/
click_signals[LONG_PRESS] =
g_signal_new (I_("long-press"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterClickActionClass, long_press),
NULL, NULL,
_clutter_marshal_BOOLEAN__OBJECT_ENUM,
G_TYPE_BOOLEAN, 2,
CLUTTER_TYPE_ACTOR,
CLUTTER_TYPE_LONG_PRESS_STATE);
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
}
static void
clutter_click_action_init (ClutterClickAction *self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CLUTTER_TYPE_CLICK_ACTION,
ClutterClickActionPrivate);
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
self->priv->long_press_threshold = -1;
self->priv->long_press_duration = -1;
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
}
/**
* clutter_click_action_new:
*
* Creates a new #ClutterClickAction instance
*
* Return value: the newly created #ClutterClickAction
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
action: Add ClickAction ClickAction adds "clickable" semantics to an actor. It provides all the business logic to emit a high-level "clicked" signal from the various low-level signals inside ClutterActor.
2010-05-24 09:41:19 +00:00
*/
ClutterAction *
clutter_click_action_new (void)
{
return g_object_new (CLUTTER_TYPE_CLICK_ACTION, NULL);
}
click-action: Add a method to force a release It can be useful to be able to forcibly break the grab set up by the ClickAction. The newly added release() method provides a mechanism to release the grab and unset the :held state of the ClickAction.
2010-08-19 11:10:43 +00:00
/**
* clutter_click_action_release:
* @action: a #ClutterClickAction
*
* Emulates a release of the pointer button, which ungrabs the pointer
* and unsets the #ClutterClickAction:pressed state.
*
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
* This function will also cancel the long press gesture if one was
* initiated.
*
click-action: Add a method to force a release It can be useful to be able to forcibly break the grab set up by the ClickAction. The newly added release() method provides a mechanism to release the grab and unset the :held state of the ClickAction.
2010-08-19 11:10:43 +00:00
* This function is useful to break a grab, for instance after a certain
* amount of time has passed.
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
click-action: Add a method to force a release It can be useful to be able to forcibly break the grab set up by the ClickAction. The newly added release() method provides a mechanism to release the grab and unset the :held state of the ClickAction.
2010-08-19 11:10:43 +00:00
*/
void
click-action: Fix the release() method name Documented and declared as release(), it's implemented as force_release(). http://bugzilla.clutter-project.org/show_bug.cgi?id=2286
2010-08-26 15:36:06 +00:00
clutter_click_action_release (ClutterClickAction *action)
click-action: Add a method to force a release It can be useful to be able to forcibly break the grab set up by the ClickAction. The newly added release() method provides a mechanism to release the grab and unset the :held state of the ClickAction.
2010-08-19 11:10:43 +00:00
{
ClutterClickActionPrivate *priv;
g_return_if_fail (CLUTTER_IS_CLICK_ACTION (action));
priv = action->priv;
if (!priv->is_held)
return;
click-action: don't use pointer grabs The same behavior can be achieved by capturing events on stage while button is pressed. This fixes a problem when using click and drag actions on the same actor as there no grabs involved. http://bugzilla.clutter-project.org/show_bug.cgi?id=2409
2010-11-11 22:23:09 +00:00
/* disconnect the capture */
if (priv->capture_id != 0)
{
g_signal_handler_disconnect (priv->stage, priv->capture_id);
priv->capture_id = 0;
}
click-action: Add a method to force a release It can be useful to be able to forcibly break the grab set up by the ClickAction. The newly added release() method provides a mechanism to release the grab and unset the :held state of the ClickAction.
2010-08-19 11:10:43 +00:00
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
click_action_cancel_long_press (action);
click_action_set_held (action, FALSE);
click-action: Add a method to force a release It can be useful to be able to forcibly break the grab set up by the ClickAction. The newly added release() method provides a mechanism to release the grab and unset the :held state of the ClickAction.
2010-08-19 11:10:43 +00:00
click_action_set_pressed (action, FALSE);
}
click-action: Add get_button() Allow retrieving the pointer button that caused the ::clicked signal to be emitted. http://bugzilla.clutter-project.org/show_bug.cgi?id=2287
2010-08-26 15:36:59 +00:00
/**
* clutter_click_action_get_button:
* @action: a #ClutterClickAction
*
* Retrieves the button that was pressed.
*
* Return value: the button value
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
click-action: Add get_button() Allow retrieving the pointer button that caused the ::clicked signal to be emitted. http://bugzilla.clutter-project.org/show_bug.cgi?id=2287
2010-08-26 15:36:59 +00:00
*/
guint
clutter_click_action_get_button (ClutterClickAction *action)
{
g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);
return action->priv->press_button;
}
click-action: add API to get modifier type This is to allow implementing modified click such as ctrl+click, shift+click, and so on. http://bugzilla.clutter-project.org/show_bug.cgi?id=2520
2011-01-17 00:38:04 +00:00
/**
* clutter_click_action_get_state:
* @action: a #ClutterClickAction
*
* Retrieves the modifier state of the click action.
*
* Return value: the modifier state parameter, or 0
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
click-action: add API to get modifier type This is to allow implementing modified click such as ctrl+click, shift+click, and so on. http://bugzilla.clutter-project.org/show_bug.cgi?id=2520
2011-01-17 00:38:04 +00:00
*/
ClutterModifierType
clutter_click_action_get_state (ClutterClickAction *action)
{
g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);
return action->priv->modifier_state;
}
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
/**
* clutter_click_action_get_coords:
* @action: a #ClutterClickAction
* @press_x: (out): return location for the X coordinate, or %NULL
* @press_y: (out): return location for the Y coordinate, or %NULL
*
* Retrieves the screen coordinates of the button press.
*
2.0: Remove all Since: annotations We're starting from scratch.
2012-08-27 08:48:36 +00:00
*
click-action: Add support for long press detection A long press is a special form of click action; the default implementation uses a single signal with multiple states: query, action and cancel. On click we use the "query" state to check whether the ClutterClickAction supports long presses; if the callback returns TRUE then we install a timeout and we either emit the "activate" state when the timeout expires or we emit the "cancel" state if the pointer leaves the actor, or if the pointer moves outside a certain threshold. If the long press reached the "activate" state then we skip the clicked signal emission.
2011-05-18 10:21:58 +00:00
*/
void
clutter_click_action_get_coords (ClutterClickAction *action,
gfloat *press_x,
gfloat *press_y)
{
g_return_if_fail (CLUTTER_IS_ACTION (action));
if (press_x != NULL)
*press_x = action->priv->press_x;
if (press_y != NULL)
*press_y = action->priv->press_y;
}
Reference in New Issue Copy Permalink