brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

2.0: First pass at deprecated API removal

Browse Source 
This is the minimum required commit to get Clutter and the examples
building.
This commit is contained in:
Emmanuele Bassi 2012-08-23 17:37:40 +01:00
parent 4da1b8b523
commit a2993f5de3
12 changed files with 67 additions and 3245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
clutter/clutter-actor-private.h
View File

@ -183,22 +183,13 @@ struct _ClutterTransformInfo
{ {
/* rotation (angle and center) */ /* rotation (angle and center) */
gdouble rx_angle; gdouble rx_angle;
AnchorCoord rx_center;
gdouble ry_angle; gdouble ry_angle;
AnchorCoord ry_center;
gdouble rz_angle; gdouble rz_angle;
AnchorCoord rz_center;
/* scaling */ /* scaling */
gdouble scale_x; gdouble scale_x;
gdouble scale_y; gdouble scale_y;
gdouble scale_z; gdouble scale_z;
AnchorCoord scale_center;
/* anchor point */
AnchorCoord anchor;
/* translation */ /* translation */
ClutterVertex translation; ClutterVertex translation;

2287
clutter/clutter-actor.c
View File

File diff suppressed because it is too large Load Diff

74
clutter/clutter-animatable.c
View File

@ -67,80 +67,6 @@ clutter_animatable_default_init (ClutterAnimatableInterface *iface)
{ {
} }
/**
* clutter_animatable_animate_property:
* @animatable: a #ClutterAnimatable
* @animation: a #ClutterAnimation
* @property_name: the name of the animated property
* @initial_value: the initial value of the animation interval
* @final_value: the final value of the animation interval
* @progress: the progress factor
* @value: return location for the animation value
*
* Calls the animate_property() virtual function for @animatable.
*
* The @initial_value and @final_value #GValue<!-- -->s must contain
* the same type; @value must have been initialized to the same
* type of @initial_value and @final_value.
*
* All implementation of the #ClutterAnimatable interface must
* implement this function.
*
* Return value: %TRUE if the value has been validated and can
* be applied to the #ClutterAnimatable, and %FALSE otherwise
*
* Since: 1.0
*
* Deprecated: 1.8: Use clutter_animatable_interpolate_value()
* instead
*/
gboolean
clutter_animatable_animate_property (ClutterAnimatable *animatable,
ClutterAnimation *animation,
const gchar *property_name,
const GValue *initial_value,
const GValue *final_value,
gdouble progress,
GValue *value)
{
ClutterAnimatableIface *iface;
gboolean res;
g_return_val_if_fail (CLUTTER_IS_ANIMATABLE (animatable), FALSE);
g_return_val_if_fail (CLUTTER_IS_ANIMATION (animation), FALSE);
g_return_val_if_fail (property_name != NULL, FALSE);
g_return_val_if_fail (initial_value != NULL && final_value != NULL, FALSE);
g_return_val_if_fail (G_VALUE_TYPE (initial_value) != G_TYPE_INVALID, FALSE);
g_return_val_if_fail (G_VALUE_TYPE (final_value) != G_TYPE_INVALID, FALSE);
g_return_val_if_fail (value != NULL, FALSE);
g_return_val_if_fail (G_VALUE_TYPE (value) == G_VALUE_TYPE (initial_value) &&
G_VALUE_TYPE (value) == G_VALUE_TYPE (final_value),
FALSE);
iface = CLUTTER_ANIMATABLE_GET_IFACE (animatable);
if (iface->animate_property == NULL)
{
ClutterInterval *interval;
interval = clutter_animation_get_interval (animation, property_name);
if (interval == NULL)
return FALSE;
res = clutter_animatable_interpolate_value (animatable, property_name,
interval,
progress,
value);
}
else
res = iface->animate_property (animatable, animation,
property_name,
initial_value, final_value,
progress,
value);
return res;
}
/** /**
* clutter_animatable_find_property: * clutter_animatable_find_property:
* @animatable: a #ClutterAnimatable * @animatable: a #ClutterAnimatable

15
clutter/clutter-interval.c
View File

@ -103,21 +103,6 @@ clutter_interval_real_validate (ClutterInterval *interval,
{ {
GType pspec_gtype = G_PARAM_SPEC_VALUE_TYPE (pspec); GType pspec_gtype = G_PARAM_SPEC_VALUE_TYPE (pspec);
/* check the GTypes we provide first */
if (pspec_gtype == COGL_TYPE_FIXED)
{
ClutterParamSpecFixed *pspec_fixed = CLUTTER_PARAM_SPEC_FIXED (pspec);
CoglFixed a, b;
a = b = 0;
clutter_interval_get_interval (interval, &a, &b);
if ((a >= pspec_fixed->minimum && a <= pspec_fixed->maximum) &&
(b >= pspec_fixed->minimum && b <= pspec_fixed->maximum))
return TRUE;
else
return FALSE;
}
/* then check the fundamental types */ /* then check the fundamental types */
switch (G_TYPE_FUNDAMENTAL (pspec_gtype)) switch (G_TYPE_FUNDAMENTAL (pspec_gtype))
{ {

281
clutter/clutter-layout-manager.c
View File

@ -79,173 +79,6 @@
* function whenever one of these properties changes.</para> * function whenever one of these properties changes.</para>
* </refsect2> * </refsect2>
* *
* <refsect2 id="ClutterLayoutManager-animation">
* <title>Animating a ClutterLayoutManager</title>
* <para>A layout manager is used to let a #ClutterContainer take complete
* ownership over the layout (that is: the position and sizing) of its
* children; this means that using the Clutter animation API, like
* clutter_actor_animate(), to animate the position and sizing of a child of
* a layout manager it is not going to work properly, as the animation will
* automatically override any setting done by the layout manager
* itself.</para>
* <para>It is possible for a #ClutterLayoutManager sub-class to animate its
* children layout by using the base class animation support. The
* #ClutterLayoutManager animation support consists of three virtual
* functions: #ClutterLayoutManagerClass.begin_animation(),
* #ClutterLayoutManagerClass.get_animation_progress(), and
* #ClutterLayoutManagerClass.end_animation().</para>
* <variablelist>
* <varlistentry>
* <term><function>begin_animation (duration, easing)</function></term>
* <listitem><para>This virtual function is invoked when the layout
* manager should begin an animation. The implementation should set up
* the state for the animation and create the ancillary objects for
* animating the layout. The default implementation creates a
* #ClutterTimeline for the given duration and a #ClutterAlpha binding
* the timeline to the given easing mode. This function returns a
* #ClutterAlpha which should be used to control the animation from
* the caller perspective.</para></listitem>
* </varlistentry>
* <varlistentry>
* <term><function>get_animation_progress()</function></term>
* <listitem><para>This virtual function should be invoked when animating
* a layout manager. It returns the progress of the animation, using the
* same semantics as the #ClutterAlpha:alpha value.</para></listitem>
* </varlistentry>
* <varlistentry>
* <term><function>end_animation()</function></term>
* <listitem><para>This virtual function is invoked when the animation of
* a layout manager ends, and it is meant to be used for bookkeeping the
* objects created in the <function>begin_animation()</function>
* function. The default implementation will call it implicitly when the
* timeline is complete.</para></listitem>
* </varlistentry>
* </variablelist>
* <para>The simplest way to animate a layout is to create a #ClutterTimeline
* inside the <function>begin_animation()</function> virtual function, along
* with a #ClutterAlpha, and for each #ClutterTimeline::new-frame signal
* emission call clutter_layout_manager_layout_changed(), which will cause a
* relayout. The #ClutterTimeline::completed signal emission should cause
* clutter_layout_manager_end_animation() to be called. The default
* implementation provided internally by #ClutterLayoutManager does exactly
* this, so most sub-classes should either not override any animation-related
* virtual function or simply override #ClutterLayoutManagerClass.begin_animation()
* and #ClutterLayoutManagerClass.end_animation() to set up ad hoc state, and then
* chain up to the parent's implementation.</para>
* <example id="example-ClutterLayoutManager-animation">
* <title>Animation of a Layout Manager</title>
* <para>The code below shows how a #ClutterLayoutManager sub-class should
* provide animating the allocation of its children from within the
* #ClutterLayoutManagerClass.allocate() virtual function implementation. The
* animation is computed between the last stable allocation performed
* before the animation started and the desired final allocation.</para>
* <para>The <varname>is_animating</varname> variable is stored inside the
* #ClutterLayoutManager sub-class and it is updated by overriding the
* #ClutterLayoutManagerClass.begin_animation() and the
* #ClutterLayoutManagerClass.end_animation() virtual functions and chaining up
* to the base class implementation.</para>
* <para>The last stable allocation is stored within a #ClutterLayoutMeta
* sub-class used by the implementation.</para>
* <programlisting>
* static void
* my_layout_manager_allocate (ClutterLayoutManager *manager,
* ClutterContainer *container,
* const ClutterActorBox *allocation,
* ClutterAllocationFlags flags)
* {
* MyLayoutManager *self = MY_LAYOUT_MANAGER (manager);
* ClutterActor *child;
*
* for (child = clutter_actor_get_first_child (CLUTTER_ACTOR (container));
* child != NULL;
* child = clutter_actor_get_next_sibling (child))
* {
* ClutterLayoutMeta *meta;
* MyLayoutMeta *my_meta;
*
* /&ast; retrieve the layout meta-object &ast;/
* meta = clutter_layout_manager_get_child_meta (manager,
* container,
* child);
* my_meta = MY_LAYOUT_META (meta);
*
* /&ast; compute the desired allocation for the child &ast;/
* compute_allocation (self, my_meta, child,
* allocation, flags,
* &amp;child_box);
*
* /&ast; this is the additional code that deals with the animation
* &ast; of the layout manager
* &ast;/
* if (!self-&gt;is_animating)
* {
* /&ast; store the last stable allocation for later use &ast;/
* my_meta-&gt;last_alloc = clutter_actor_box_copy (&amp;child_box);
* }
* else
* {
* ClutterActorBox end = { 0, };
* gdouble p;
*
* /&ast; get the progress of the animation &ast;/
* p = clutter_layout_manager_get_animation_progress (manager);
*
* if (my_meta-&gt;last_alloc != NULL)
* {
* /&ast; copy the desired allocation as the final state &ast;/
* end = child_box;
*
* /&ast; then interpolate the initial and final state
* &ast; depending on the progress of the animation,
* &ast; and put the result inside the box we will use
* &ast; to allocate the child
* &ast;/
* clutter_actor_box_interpolate (my_meta-&gt;last_alloc,
* &amp;end,
* p,
* &amp;child_box);
* }
* else
* {
* /&ast; if there is no stable allocation then the child was
* &ast; added while animating; one possible course of action
* &ast; is to just bail out and fall through to the allocation
* &ast; to position the child directly at its final state
* &ast;/
* my_meta-&gt;last_alloc =
* clutter_actor_box_copy (&amp;child_box);
* }
* }
*
* /&ast; allocate the child &ast;/
* clutter_actor_allocate (child, &child_box, flags);
* }
* }
* </programlisting>
* </example>
* <para>Sub-classes of #ClutterLayoutManager that support animations of the
* layout changes should call clutter_layout_manager_begin_animation()
* whenever a layout property changes value, e.g.:</para>
* <informalexample>
* <programlisting>
* if (self->orientation != new_orientation)
* {
* ClutterLayoutManager *manager;
*
* self->orientation = new_orientation;
*
* manager = CLUTTER_LAYOUT_MANAGER (self);
* clutter_layout_manager_layout_changed (manager);
* clutter_layout_manager_begin_animation (manager, 500, CLUTTER_LINEAR);
*
* g_object_notify (G_OBJECT (self), "orientation");
* }
* </programlisting>
* </informalexample>
* <para>The code above will animate a change in the
* <varname>orientation</varname> layout property of a layout manager.</para>
* </refsect2>
*
* <refsect2 id="clutter-layout-properties"> * <refsect2 id="clutter-layout-properties">
* <title>Layout Properties</title> * <title>Layout Properties</title>
* <para>If a layout manager has layout properties, that is properties that * <para>If a layout manager has layout properties, that is properties that
@ -362,7 +195,6 @@ G_DEFINE_ABSTRACT_TYPE (ClutterLayoutManager,
G_TYPE_INITIALLY_UNOWNED); G_TYPE_INITIALLY_UNOWNED);
static GQuark quark_layout_meta = 0; static GQuark quark_layout_meta = 0;
static GQuark quark_layout_alpha = 0;
static guint manager_signals[LAST_SIGNAL] = { 0, }; static guint manager_signals[LAST_SIGNAL] = { 0, };
@ -375,15 +207,15 @@ layout_manager_freeze_layout_change (ClutterLayoutManager *manager)
G_OBJECT_TYPE_NAME (manager), G_OBJECT_TYPE_NAME (manager),
manager); manager);
is_frozen = g_object_get_data (G_OBJECT (manager), "freeze-change"); is_frozen = g_object_get_data (G_OBJECT (manager), "-clutter-layout-manager-freeze-change");
if (is_frozen == NULL) if (is_frozen == NULL)
g_object_set_data (G_OBJECT (manager), "freeze-change", g_object_set_data (G_OBJECT (manager), "-clutter-layout-manager-freeze-change",
GUINT_TO_POINTER (1)); GUINT_TO_POINTER (1));
else else
{ {
guint level = GPOINTER_TO_UINT (is_frozen) + 1; guint level = GPOINTER_TO_UINT (is_frozen) + 1;
g_object_set_data (G_OBJECT (manager), "freeze-change", g_object_set_data (G_OBJECT (manager), "-clutter-layout-manager-freeze-change",
GUINT_TO_POINTER (level)); GUINT_TO_POINTER (level));
} }
} }
@ -393,7 +225,7 @@ layout_manager_thaw_layout_change (ClutterLayoutManager *manager)
{ {
gpointer is_frozen; gpointer is_frozen;
is_frozen = g_object_get_data (G_OBJECT (manager), "freeze-change"); is_frozen = g_object_get_data (G_OBJECT (manager), "-clutter-layout-manager-freeze-change");
if (is_frozen == NULL) if (is_frozen == NULL)
g_critical (G_STRLOC ": Mismatched thaw; you have to call " g_critical (G_STRLOC ": Mismatched thaw; you have to call "
"clutter_layout_manager_freeze_layout_change() prior to " "clutter_layout_manager_freeze_layout_change() prior to "
@ -410,9 +242,9 @@ layout_manager_thaw_layout_change (ClutterLayoutManager *manager)
level -= 1; level -= 1;
if (level == 0) if (level == 0)
g_object_set_data (G_OBJECT (manager), "freeze-change", NULL); g_object_set_data (G_OBJECT (manager), "-clutter-layout-manager-freeze-change", NULL);
else else
g_object_set_data (G_OBJECT (manager), "freeze-change", g_object_set_data (G_OBJECT (manager), "-clutter-layout-manager-freeze-change",
GUINT_TO_POINTER (level)); GUINT_TO_POINTER (level));
} }
@ -464,7 +296,7 @@ layout_manager_real_set_container (ClutterLayoutManager *manager,
ClutterContainer *container) ClutterContainer *container)
{ {
if (container != NULL) if (container != NULL)
g_object_set_data (G_OBJECT (container), "clutter-layout-manager", manager); g_object_set_data (G_OBJECT (container), "-clutter-layout-manager", manager);
} }
static ClutterLayoutMeta * static ClutterLayoutMeta *
@ -499,101 +331,11 @@ layout_manager_real_get_child_meta_type (ClutterLayoutManager *manager)
return G_TYPE_INVALID; return G_TYPE_INVALID;
} }
/* XXX:2.0 - Remove */
static ClutterAlpha *
layout_manager_real_begin_animation (ClutterLayoutManager *manager,
guint duration,
gulong mode)
{
ClutterTimeline *timeline;
ClutterAlpha *alpha;
alpha = g_object_get_qdata (G_OBJECT (manager), quark_layout_alpha);
if (alpha != NULL)
{
clutter_alpha_set_mode (alpha, mode);
timeline = clutter_alpha_get_timeline (alpha);
clutter_timeline_set_duration (timeline, duration);
clutter_timeline_rewind (timeline);
return alpha;
};
timeline = clutter_timeline_new (duration);
alpha = clutter_alpha_new_full (timeline, mode);
/* let the alpha take ownership of the timeline */
g_object_unref (timeline);
g_signal_connect_swapped (timeline, "completed",
G_CALLBACK (clutter_layout_manager_end_animation),
manager);
g_signal_connect_swapped (timeline, "new-frame",
G_CALLBACK (clutter_layout_manager_layout_changed),
manager);
g_object_set_qdata_full (G_OBJECT (manager),
quark_layout_alpha, alpha,
(GDestroyNotify) g_object_unref);
clutter_timeline_start (timeline);
return alpha;
}
/* XXX:2.0 - Remove */
static gdouble
layout_manager_real_get_animation_progress (ClutterLayoutManager *manager)
{
ClutterAlpha *alpha;
alpha = g_object_get_qdata (G_OBJECT (manager), quark_layout_alpha);
if (alpha == NULL)
return 1.0;
return clutter_alpha_get_alpha (alpha);
}
/* XXX:2.0 - Remove */
static void
layout_manager_real_end_animation (ClutterLayoutManager *manager)
{
ClutterTimeline *timeline;
ClutterAlpha *alpha;
alpha = g_object_get_qdata (G_OBJECT (manager), quark_layout_alpha);
if (alpha == NULL)
return;
timeline = clutter_alpha_get_timeline (alpha);
g_assert (timeline != NULL);
if (clutter_timeline_is_playing (timeline))
clutter_timeline_stop (timeline);
g_signal_handlers_disconnect_by_func (timeline,
G_CALLBACK (clutter_layout_manager_end_animation),
manager);
g_signal_handlers_disconnect_by_func (timeline,
G_CALLBACK (clutter_layout_manager_layout_changed),
manager);
g_object_set_qdata (G_OBJECT (manager), quark_layout_alpha, NULL);
clutter_layout_manager_layout_changed (manager);
}
static void static void
clutter_layout_manager_class_init (ClutterLayoutManagerClass *klass) clutter_layout_manager_class_init (ClutterLayoutManagerClass *klass)
{ {
quark_layout_meta = quark_layout_meta =
g_quark_from_static_string ("clutter-layout-manager-child-meta"); g_quark_from_static_string ("-clutter-layout-manager-child-meta");
/* XXX:2.0 - Remove */
quark_layout_alpha =
g_quark_from_static_string ("clutter-layout-manager-alpha");
g_type_class_add_private (klass, sizeof (ClutterLayoutManagerPrivate)); g_type_class_add_private (klass, sizeof (ClutterLayoutManagerPrivate));
@ -602,11 +344,6 @@ clutter_layout_manager_class_init (ClutterLayoutManagerClass *klass)
klass->allocate = layout_manager_real_allocate; klass->allocate = layout_manager_real_allocate;
klass->create_child_meta = layout_manager_real_create_child_meta; klass->create_child_meta = layout_manager_real_create_child_meta;
klass->get_child_meta_type = layout_manager_real_get_child_meta_type; klass->get_child_meta_type = layout_manager_real_get_child_meta_type;
/* XXX:2.0 - Remove */
klass->begin_animation = layout_manager_real_begin_animation;
klass->get_animation_progress = layout_manager_real_get_animation_progress;
klass->end_animation = layout_manager_real_end_animation;
klass->set_container = layout_manager_real_set_container; klass->set_container = layout_manager_real_set_container;
/** /**
@ -775,7 +512,7 @@ clutter_layout_manager_layout_changed (ClutterLayoutManager *manager)
g_return_if_fail (CLUTTER_IS_LAYOUT_MANAGER (manager)); g_return_if_fail (CLUTTER_IS_LAYOUT_MANAGER (manager));
is_frozen = g_object_get_data (G_OBJECT (manager), "freeze-change"); is_frozen = g_object_get_data (G_OBJECT (manager), "-clutter-layout-manager-freeze-change");
if (is_frozen == NULL) if (is_frozen == NULL)
g_signal_emit (manager, manager_signals[LAYOUT_CHANGED], 0); g_signal_emit (manager, manager_signals[LAYOUT_CHANGED], 0);
else else

20
clutter/clutter-layout-manager.h
View File

@ -79,17 +79,6 @@ struct _ClutterLayoutManager
* @create_child_meta: virtual function; override to create a * @create_child_meta: virtual function; override to create a
* #ClutterLayoutMeta instance associated to a #ClutterContainer and a * #ClutterLayoutMeta instance associated to a #ClutterContainer and a
* child #ClutterActor, used to maintain layout manager specific properties * child #ClutterActor, used to maintain layout manager specific properties
* @begin_animation: virtual function; override to control the animation
* of a #ClutterLayoutManager with the given duration and easing mode.
* This virtual function is deprecated, and it should not be overridden
* in newly written code.
* @end_animation: virtual function; override to end an animation started
* by clutter_layout_manager_begin_animation(). This virtual function is
* deprecated, and it should not be overriden in newly written code.
* @get_animation_progress: virtual function; override to control the
* progress of the animation of a #ClutterLayoutManager. This virtual
* function is deprecated, and it should not be overridden in newly written
* code.
* @layout_changed: class handler for the #ClutterLayoutManager::layout-changed * @layout_changed: class handler for the #ClutterLayoutManager::layout-changed
* signal * signal
* *
@ -127,15 +116,6 @@ struct _ClutterLayoutManagerClass
ClutterContainer *container, ClutterContainer *container,
ClutterActor *actor); ClutterActor *actor);
/* deprecated */
ClutterAlpha * (* begin_animation) (ClutterLayoutManager *manager,
guint duration,
gulong mode);
/* deprecated */
gdouble (* get_animation_progress) (ClutterLayoutManager *manager);
/* deprecated */
void (* end_animation) (ClutterLayoutManager *manager);
void (* layout_changed) (ClutterLayoutManager *manager); void (* layout_changed) (ClutterLayoutManager *manager);
/*< private >*/ /*< private >*/

259
clutter/clutter-script-parser.c
View File

@ -34,22 +34,16 @@
#include <glib.h> #include <glib.h>
#include <gmodule.h> #include <gmodule.h>
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "deprecated/clutter-container.h"
#include "deprecated/clutter-alpha.h"
#include "clutter-actor.h" #include "clutter-actor.h"
#include "clutter-container.h"
#include "clutter-debug.h" #include "clutter-debug.h"
#include "clutter-enum-types.h" #include "clutter-enum-types.h"
#include "clutter-private.h"
#include "clutter-script.h" #include "clutter-script.h"
#include "clutter-script-private.h" #include "clutter-script-private.h"
#include "clutter-scriptable.h" #include "clutter-scriptable.h"
#include "clutter-stage-manager.h" #include "clutter-stage-manager.h"
#include "clutter-private.h"
static void clutter_script_parser_object_end (JsonParser *parser, static void clutter_script_parser_object_end (JsonParser *parser,
JsonObject *object); JsonObject *object);
static void clutter_script_parser_parse_end (JsonParser *parser); static void clutter_script_parser_parse_end (JsonParser *parser);
@ -707,42 +701,8 @@ parse_signals (ClutterScript *script,
} }
} }
/* mandatory: "target-state" or "handler" */ /* mandatory: "handler" */
if (json_object_has_member (object, "target-state")) if (json_object_has_member (object, "handler"))
{
const gchar *state = NULL;
const gchar *target = NULL;
gboolean warp_to = FALSE;
target = json_object_get_string_member (object, "target-state");
if (target == NULL)
{
_clutter_script_warn_invalid_value (script,
"target-state", "string",
val);
continue;
}
if (json_object_has_member (object, "states"))
state = json_object_get_string_member (object, "states");
if (json_object_has_member (object, "warp"))
warp_to = json_object_get_boolean_member (object, "warp");
CLUTTER_NOTE (SCRIPT,
"Added signal '%s' (states:%s, target-state:%s, warp:%s)",
name,
state != NULL ? state : "<default>", target,
warp_to ? "true" : "false");
sinfo = g_slice_new0 (SignalInfo);
sinfo->is_handler = FALSE;
sinfo->name = g_strdup (name);
sinfo->state = g_strdup (state);
sinfo->target = g_strdup (target);
sinfo->warp_to = warp_to;
}
else if (json_object_has_member (object, "handler"))
{ {
const gchar *handler; const gchar *handler;
const gchar *connect; const gchar *connect;
@ -792,7 +752,7 @@ parse_signals (ClutterScript *script,
else else
_clutter_script_warn_missing_attribute (script, _clutter_script_warn_missing_attribute (script,
NULL, NULL,
"handler or state"); "handler");
if (sinfo != NULL) if (sinfo != NULL)
retval = g_list_prepend (retval, sinfo); retval = g_list_prepend (retval, sinfo);
} }
@ -800,98 +760,10 @@ parse_signals (ClutterScript *script,
return retval; return retval;
} }
static ClutterTimeline *
construct_timeline (ClutterScript *script,
JsonObject *object)
{
ClutterTimeline *retval = NULL;
ObjectInfo *oinfo;
GList *members, *l;
/* we fake an ObjectInfo so we can reuse clutter_script_construct_object()
* here; we do not save it inside the hash table, because if this had
* been a named object then we wouldn't have ended up here in the first
* place
*/
oinfo = g_slice_new0 (ObjectInfo);
oinfo->gtype = CLUTTER_TYPE_TIMELINE;
oinfo->id = g_strdup ("dummy");
members = json_object_get_members (object);
for (l = members; l != NULL; l = l->next)
{
const gchar *name = l->data;
JsonNode *node = json_object_get_member (object, name);
PropertyInfo *pinfo = g_slice_new0 (PropertyInfo);
pinfo->name = g_strdelimit (g_strdup (name), G_STR_DELIMITERS, '-');
pinfo->node = json_node_copy (node);
oinfo->properties = g_list_prepend (oinfo->properties, pinfo);
}
g_list_free (members);
_clutter_script_construct_object (script, oinfo);
_clutter_script_apply_properties (script, oinfo);
retval = CLUTTER_TIMELINE (oinfo->object);
/* we transfer ownership to the alpha function, so we ref before
* destroying the ObjectInfo to avoid the timeline going away
*/
g_object_ref (retval);
object_info_free (oinfo);
return retval;
}
/* define the names of the animation modes to match the ones
* that developers might be more accustomed to
*/
static const struct
{
const gchar *name;
ClutterAnimationMode mode;
} animation_modes[] = {
{ "linear", CLUTTER_LINEAR },
{ "easeInQuad", CLUTTER_EASE_IN_QUAD },
{ "easeOutQuad", CLUTTER_EASE_OUT_QUAD },
{ "easeInOutQuad", CLUTTER_EASE_IN_OUT_QUAD },
{ "easeInCubic", CLUTTER_EASE_IN_CUBIC },
{ "easeOutCubic", CLUTTER_EASE_OUT_CUBIC },
{ "easeInOutCubic", CLUTTER_EASE_IN_OUT_CUBIC },
{ "easeInQuart", CLUTTER_EASE_IN_QUART },
{ "easeOutQuart", CLUTTER_EASE_OUT_QUART },
{ "easeInOutQuart", CLUTTER_EASE_IN_OUT_QUART },
{ "easeInQuint", CLUTTER_EASE_IN_QUINT },
{ "easeOutQuint", CLUTTER_EASE_OUT_QUINT },
{ "easeInOutQuint", CLUTTER_EASE_IN_OUT_QUINT },
{ "easeInSine", CLUTTER_EASE_IN_SINE },
{ "easeOutSine", CLUTTER_EASE_OUT_SINE },
{ "easeInOutSine", CLUTTER_EASE_IN_OUT_SINE },
{ "easeInExpo", CLUTTER_EASE_IN_EXPO },
{ "easeOutExpo", CLUTTER_EASE_OUT_EXPO },
{ "easeInOutExpo", CLUTTER_EASE_IN_OUT_EXPO },
{ "easeInCirc", CLUTTER_EASE_IN_CIRC },
{ "easeOutCirc", CLUTTER_EASE_OUT_CIRC },
{ "easeInOutCirc", CLUTTER_EASE_IN_OUT_CIRC },
{ "easeInElastic", CLUTTER_EASE_IN_ELASTIC },
{ "easeOutElastic", CLUTTER_EASE_OUT_ELASTIC },
{ "easeInOutElastic", CLUTTER_EASE_IN_OUT_ELASTIC },
{ "easeInBack", CLUTTER_EASE_IN_BACK },
{ "easeOutBack", CLUTTER_EASE_OUT_BACK },
{ "easeInOutBack", CLUTTER_EASE_IN_OUT_BACK },
{ "easeInBounce", CLUTTER_EASE_IN_BOUNCE },
{ "easeOutBounce", CLUTTER_EASE_OUT_BOUNCE },
{ "easeInOutBounce", CLUTTER_EASE_IN_OUT_BOUNCE },
};
static const gint n_animation_modes = G_N_ELEMENTS (animation_modes);
gulong gulong
_clutter_script_resolve_animation_mode (JsonNode *node) _clutter_script_resolve_animation_mode (JsonNode *node)
{ {
gint i, res = CLUTTER_CUSTOM_MODE; gint res = CLUTTER_CUSTOM_MODE;
if (JSON_NODE_TYPE (node) != JSON_NODE_VALUE) if (JSON_NODE_TYPE (node) != JSON_NODE_VALUE)
return CLUTTER_CUSTOM_MODE; return CLUTTER_CUSTOM_MODE;
@ -903,18 +775,6 @@ _clutter_script_resolve_animation_mode (JsonNode *node)
{ {
const gchar *name = json_node_get_string (node); const gchar *name = json_node_get_string (node);
/* XXX - we might be able to optimize by changing the ordering
* of the animation_modes array, e.g.
* - special casing linear
* - tokenizing ('ease', 'In', 'Sine') and matching on token
* - binary searching?
*/
for (i = 0; i < n_animation_modes; i++)
{
if (strcmp (animation_modes[i].name, name) == 0)
return animation_modes[i].mode;
}
if (_clutter_script_enum_from_string (CLUTTER_TYPE_ANIMATION_MODE, if (_clutter_script_enum_from_string (CLUTTER_TYPE_ANIMATION_MODE,
name, name,
&res)) &res))
@ -926,106 +786,6 @@ _clutter_script_resolve_animation_mode (JsonNode *node)
return CLUTTER_CUSTOM_MODE; return CLUTTER_CUSTOM_MODE;
} }
static ClutterAlphaFunc
resolve_alpha_func (const gchar *name)
{
static GModule *module = NULL;
ClutterAlphaFunc func;
CLUTTER_NOTE (SCRIPT, "Looking up '%s' alpha function", name);
if (G_UNLIKELY (!module))
module = g_module_open (NULL, 0);
if (g_module_symbol (module, name, (gpointer) &func))
{
CLUTTER_NOTE (SCRIPT, "Found '%s' alpha function in the symbols table",
name);
return func;
}
return NULL;
}
GObject *
_clutter_script_parse_alpha (ClutterScript *script,
JsonNode *node)
{
GObject *retval = NULL;
JsonObject *object;
ClutterTimeline *timeline = NULL;
ClutterAlphaFunc alpha_func = NULL;
ClutterAnimationMode mode = CLUTTER_CUSTOM_MODE;
JsonNode *val;
gboolean unref_timeline = FALSE;
if (JSON_NODE_TYPE (node) != JSON_NODE_OBJECT)
return NULL;
object = json_node_get_object (node);
val = json_object_get_member (object, "timeline");
if (val)
{
if (JSON_NODE_TYPE (val) == JSON_NODE_VALUE &&
json_node_get_string (val) != NULL)
{
const gchar *id_ = json_node_get_string (val);
timeline =
CLUTTER_TIMELINE (clutter_script_get_object (script, id_));
}
else if (JSON_NODE_TYPE (val) == JSON_NODE_OBJECT)
{
timeline = construct_timeline (script, json_node_get_object (val));
unref_timeline = TRUE;
}
}
val = json_object_get_member (object, "mode");
if (val != NULL)
mode = _clutter_script_resolve_animation_mode (val);
if (mode == CLUTTER_CUSTOM_MODE)
{
val = json_object_get_member (object, "function");
if (val && json_node_get_string (val) != NULL)
{
alpha_func = resolve_alpha_func (json_node_get_string (val));
if (!alpha_func)
{
g_warning ("Unable to find the function '%s' in the "
"Clutter alpha functions or the symbols table",
json_node_get_string (val));
}
}
}
CLUTTER_NOTE (SCRIPT, "Parsed alpha: %s timeline (%p) (mode:%d, func:%p)",
unref_timeline ? "implicit" : "explicit",
timeline ? timeline : 0x0,
mode != CLUTTER_CUSTOM_MODE ? mode : 0,
alpha_func ? alpha_func : 0x0);
retval = g_object_new (CLUTTER_TYPE_ALPHA, NULL);
if (mode != CLUTTER_CUSTOM_MODE)
clutter_alpha_set_mode (CLUTTER_ALPHA (retval), mode);
if (alpha_func != NULL)
clutter_alpha_set_func (CLUTTER_ALPHA (retval), alpha_func, NULL, NULL);
clutter_alpha_set_timeline (CLUTTER_ALPHA (retval), timeline);
/* if we created an implicit timeline, the Alpha has full ownership
* of it now, since it won't be accessible from ClutterScript
*/
if (unref_timeline)
g_object_unref (timeline);
return retval;
}
static void static void
clutter_script_parser_object_end (JsonParser *json_parser, clutter_script_parser_object_end (JsonParser *json_parser,
JsonObject *object) JsonObject *object)
@ -1786,7 +1546,8 @@ apply_layout_properties (ClutterScript *script,
ClutterLayoutManager *manager; ClutterLayoutManager *manager;
GType meta_type; GType meta_type;
manager = g_object_get_data (G_OBJECT (container), "clutter-layout-manager"); /* XXX:2.0 remove; only ClutterActor should have a layout manager */
manager = g_object_get_data (G_OBJECT (container), "-clutter-layout-manager");
if (manager == NULL) if (manager == NULL)
return; return;
@ -1980,7 +1741,7 @@ static void
add_children (ClutterScript *script, add_children (ClutterScript *script,
ObjectInfo *oinfo) ObjectInfo *oinfo)
{ {
ClutterContainer *container = CLUTTER_CONTAINER (oinfo->object); ClutterActor *container = CLUTTER_ACTOR (oinfo->object);
GList *l, *unresolved; GList *l, *unresolved;
unresolved = NULL; unresolved = NULL;
@ -2019,7 +1780,7 @@ add_children (ClutterScript *script,
name, name,
g_type_name (G_OBJECT_TYPE (container))); g_type_name (G_OBJECT_TYPE (container)));
clutter_container_add_actor (container, CLUTTER_ACTOR (object)); clutter_actor_add_child (container, CLUTTER_ACTOR (object));
} }
g_list_foreach (oinfo->children, (GFunc) g_free, NULL); g_list_foreach (oinfo->children, (GFunc) g_free, NULL);

5
clutter/clutter-script-private.h
View File

@ -88,13 +88,10 @@ typedef struct {
gchar *name; gchar *name;
gchar *handler; gchar *handler;
gchar *object; gchar *object;
gchar *state;
gchar *target;
GConnectFlags flags; GConnectFlags flags;
guint is_handler : 1; guint is_handler : 1;
guint warp_to : 1;
} SignalInfo; } SignalInfo;
void property_info_free (gpointer data); void property_info_free (gpointer data);
@ -128,8 +125,6 @@ gboolean _clutter_script_parse_geometry (ClutterScript *script,
gboolean _clutter_script_parse_color (ClutterScript *script, gboolean _clutter_script_parse_color (ClutterScript *script,
JsonNode *node, JsonNode *node,
ClutterColor *color); ClutterColor *color);
GObject *_clutter_script_parse_alpha (ClutterScript *script,
JsonNode *node);
gboolean _clutter_script_parse_point (ClutterScript *script, gboolean _clutter_script_parse_point (ClutterScript *script,
JsonNode *node, JsonNode *node,
ClutterPoint *point); ClutterPoint *point);

296
clutter/clutter-script.c
View File

@ -75,66 +75,6 @@
* packing rules of Clutter still apply, and an actor cannot be packed * packing rules of Clutter still apply, and an actor cannot be packed
* in multiple containers without unparenting it in between). * in multiple containers without unparenting it in between).
* *
* Behaviours and timelines can also be defined inside a UI definition
* buffer:
*
* <informalexample><programlisting><![CDATA[
* {
* "id" : "rotate-behaviour",
* "type" : "ClutterBehaviourRotate",
* "angle-start" : 0.0,
* "angle-end" : 360.0,
* "axis" : "z-axis",
* "alpha" : {
* "timeline" : { "duration" : 4000, "loop" : true },
* "mode" : "easeInSine"
* }
* }
* ]]></programlisting></informalexample>
*
* And then to apply a defined behaviour to an actor defined inside the
* definition of an actor, the "behaviour" member can be used:
*
* <informalexample><programlisting><![CDATA[
* {
* "id" : "my-rotating-actor",
* "type" : "ClutterTexture",
* ...
* "behaviours" : [ "rotate-behaviour" ]
* }
* ]]></programlisting></informalexample>
*
* A #ClutterAlpha belonging to a #ClutterBehaviour can only be defined
* implicitly like in the example above, or explicitly by setting the
* "alpha" property to point to a previously defined #ClutterAlpha, e.g.:
*
* <informalexample><programlisting><![CDATA[
* {
* "id" : "rotate-behaviour",
* "type" : "ClutterBehaviourRotate",
* "angle-start" : 0.0,
* "angle-end" : 360.0,
* "axis" : "z-axis",
* "alpha" : {
* "id" : "rotate-alpha",
* "type" : "ClutterAlpha",
* "timeline" : {
* "id" : "rotate-timeline",
* "type : "ClutterTimeline",
* "duration" : 4000,
* "loop" : true
* },
* "function" : "custom_sine_alpha"
* }
* }
* ]]></programlisting></informalexample>
*
* Implicitely defined #ClutterAlpha<!-- -->s and #ClutterTimeline<!-- -->s
* can omit the <varname>id</varname> member, as well as the
* <varname>type</varname> member, but will not be available using
* clutter_script_get_object() (they can, however, be extracted using the
* #ClutterBehaviour and #ClutterAlpha API respectively).
*
* Signal handlers can be defined inside a Clutter UI definition file and * Signal handlers can be defined inside a Clutter UI definition file and
* then autoconnected to their respective signals using the * then autoconnected to their respective signals using the
* clutter_script_connect_signals() function: * clutter_script_connect_signals() function:
@ -158,49 +98,6 @@
* respectively) and the "object" string member for calling * respectively) and the "object" string member for calling
* g_signal_connect_object() instead of g_signal_connect(). * g_signal_connect_object() instead of g_signal_connect().
* *
* Signals can also be directly attached to a specific state defined
* inside a #ClutterState instance, for instance:
*
* |[
* ...
* "signals" : [
* {
* "name" : "enter-event",
* "states" : "button-states",
* "target-state" : "hover"
* },
* {
* "name" : "leave-event",
* "states" : "button-states",
* "target-state" : "base"
* },
* {
* "name" : "button-press-event",
* "states" : "button-states",
* "target-state" : "active",
* },
* {
* "name" : "key-press-event",
* "states" : "button-states",
* "target-state" : "key-focus",
* "warp" : true
* }
* ],
* ...
* ]|
*
* The "states" key defines the #ClutterState instance to be used to
* resolve the "target-state" key; it can be either a script id for a
* #ClutterState built by the same #ClutterScript instance, or to a
* #ClutterState built in code and associated to the #ClutterScript
* instance through the clutter_script_add_states() function. If no
* "states" key is present, then the default #ClutterState associated to
* the #ClutterScript instance will be used; the default #ClutterState
* can be set using clutter_script_add_states() using a %NULL name. The
* "warp" key can be used to warp to a specific state instead of
* animating to it. State changes on signal emission will not affect
* the signal emission chain.
*
* Clutter reserves the following names, so classes defining properties * Clutter reserves the following names, so classes defining properties
* through the usual GObject registration process should avoid using these * through the usual GObject registration process should avoid using these
* names to avoid collisions: * names to avoid collisions:
@ -248,11 +145,6 @@
#include "clutter-private.h" #include "clutter-private.h"
#include "clutter-debug.h" #include "clutter-debug.h"
#include "deprecated/clutter-alpha.h"
#include "deprecated/clutter-behaviour.h"
#include "deprecated/clutter-container.h"
#include "deprecated/clutter-state.h"
enum enum
{ {
PROP_0, PROP_0,
@ -277,8 +169,6 @@ struct _ClutterScriptPrivate
ClutterScriptParser *parser; ClutterScriptParser *parser;
GHashTable *states;
gchar **search_paths; gchar **search_paths;
gchar *translation_domain; gchar *translation_domain;
@ -331,8 +221,6 @@ signal_info_free (gpointer data)
g_free (sinfo->name); g_free (sinfo->name);
g_free (sinfo->handler); g_free (sinfo->handler);
g_free (sinfo->object); g_free (sinfo->object);
g_free (sinfo->state);
g_free (sinfo->target);
g_slice_free (SignalInfo, sinfo); g_slice_free (SignalInfo, sinfo);
} }
@ -389,7 +277,6 @@ clutter_script_finalize (GObject *gobject)
g_hash_table_destroy (priv->objects); g_hash_table_destroy (priv->objects);
g_strfreev (priv->search_paths); g_strfreev (priv->search_paths);
g_free (priv->filename); g_free (priv->filename);
g_hash_table_destroy (priv->states);
g_free (priv->translation_domain); g_free (priv->translation_domain);
G_OBJECT_CLASS (clutter_script_parent_class)->finalize (gobject); G_OBJECT_CLASS (clutter_script_parent_class)->finalize (gobject);
@ -526,9 +413,6 @@ clutter_script_init (ClutterScript *script)
priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal, priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, NULL,
object_info_free); object_info_free);
priv->states = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free,
(GDestroyNotify) g_object_unref);
} }
/** /**
@ -1048,65 +932,12 @@ clutter_script_connect_signals (ClutterScript *script,
g_free (cd); g_free (cd);
} }
typedef struct {
ClutterState *state;
GObject *emitter;
gchar *target;
gulong signal_id;
gulong hook_id;
gboolean warp_to;
} HookData;
typedef struct { typedef struct {
ClutterScript *script; ClutterScript *script;
ClutterScriptConnectFunc func; ClutterScriptConnectFunc func;
gpointer user_data; gpointer user_data;
} SignalConnectData; } SignalConnectData;
static void
hook_data_free (gpointer data)
{
if (G_LIKELY (data != NULL))
{
HookData *hook_data = data;
g_free (hook_data->target);
g_slice_free (HookData, hook_data);
}
}
static gboolean
clutter_script_state_change_hook (GSignalInvocationHint *ihint,
guint n_params,
const GValue *params,
gpointer user_data)
{
HookData *hook_data = user_data;
GObject *emitter;
emitter = g_value_get_object (&params[0]);
if (emitter == hook_data->emitter)
{
if (hook_data->warp_to)
clutter_state_warp_to_state (hook_data->state, hook_data->target);
else
clutter_state_set_state (hook_data->state, hook_data->target);
}
return TRUE;
}
static void
clutter_script_remove_state_change_hook (gpointer user_data,
GObject *object_p)
{
HookData *hook_data = user_data;
g_signal_remove_emission_hook (hook_data->signal_id,
hook_data->hook_id);
}
static void static void
connect_each_object (gpointer key, connect_each_object (gpointer key,
gpointer value, gpointer value,
@ -1144,67 +975,6 @@ connect_each_object (gpointer key,
connect_data->user_data); connect_data->user_data);
} }
} }
else
{
GObject *state_object = NULL;
const gchar *signal_name, *signal_detail;
gchar **components;
GQuark signal_quark;
guint signal_id;
HookData *hook_data;
if (sinfo->state == NULL)
state_object = (GObject *) clutter_script_get_states (script, NULL);
else
{
state_object = clutter_script_get_object (script, sinfo->state);
if (state_object == NULL)
state_object = (GObject *) clutter_script_get_states (script, sinfo->state);
}
if (state_object == NULL)
continue;
components = g_strsplit (sinfo->name, "::", 2);
if (g_strv_length (components) == 2)
{
signal_name = components[0];
signal_detail = components[1];
}
else
{
signal_name = components[0];
signal_detail = NULL;
}
signal_id = g_signal_lookup (signal_name, G_OBJECT_TYPE (object));
if (signal_id == 0)
{
g_strfreev (components);
continue;
}
if (signal_detail != NULL)
signal_quark = g_quark_from_string (signal_detail);
else
signal_quark = 0;
hook_data = g_slice_new (HookData);
hook_data->emitter = object;
hook_data->state = CLUTTER_STATE (state_object);
hook_data->target = g_strdup (sinfo->target);
hook_data->warp_to = sinfo->warp_to;
hook_data->signal_id = signal_id;
hook_data->hook_id =
g_signal_add_emission_hook (signal_id, signal_quark,
clutter_script_state_change_hook,
hook_data,
hook_data_free);
g_object_weak_ref (hook_data->emitter,
clutter_script_remove_state_change_hook,
hook_data);
}
signal_info_free (sinfo); signal_info_free (sinfo);
} }
@ -1428,72 +1198,6 @@ clutter_script_list_objects (ClutterScript *script)
return retval; return retval;
} }
/**
* clutter_script_add_states:
* @script: a #ClutterScript
* @name: (allow-none): a name for the @state, or %NULL to
* set the default #ClutterState
* @state: a #ClutterState
*
* Associates a #ClutterState to the #ClutterScript instance using the given
* name.
*
* The #ClutterScript instance will use @state to resolve target states when
* connecting signal handlers.
*
* The #ClutterScript instance will take a reference on the #ClutterState
* passed to this function.
*
* Since: 1.8
*
* Deprecated: 1.12
*/
void
clutter_script_add_states (ClutterScript *script,
const gchar *name,
ClutterState *state)
{
g_return_if_fail (CLUTTER_IS_SCRIPT (script));
g_return_if_fail (CLUTTER_IS_STATE (state));
if (name == NULL || *name == '\0')
name = "__clutter_script_default_state";
g_hash_table_replace (script->priv->states,
g_strdup (name),
g_object_ref (state));
}
/**
* clutter_script_get_states:
* @script: a #ClutterScript
* @name: (allow-none): the name of the #ClutterState, or %NULL
*
* Retrieves the #ClutterState for the given @state_name.
*
* If @name is %NULL, this function will return the default
* #ClutterState instance.
*
* Return value: (transfer none): a pointer to the #ClutterState for the
* given name. The #ClutterState is owned by the #ClutterScript instance
* and it should not be unreferenced
*
* Since: 1.8
*
* Deprecated: 1.12
*/
ClutterState *
clutter_script_get_states (ClutterScript *script,
const gchar *name)
{
g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), NULL);
if (name == NULL || *name == '\0')
name = "__clutter_script_default_state";
return g_hash_table_lookup (script->priv->states, name);
}
/** /**
* clutter_script_set_translation_domain: * clutter_script_set_translation_domain:
* @script: a #ClutterScript * @script: a #ClutterScript

4
clutter/clutter-stage.c
View File

@ -81,7 +81,7 @@
static void clutter_container_iface_init (ClutterContainerIface *iface); static void clutter_container_iface_init (ClutterContainerIface *iface);
G_DEFINE_TYPE_WITH_CODE (ClutterStage, clutter_stage, CLUTTER_TYPE_GROUP, G_DEFINE_TYPE_WITH_CODE (ClutterStage, clutter_stage, CLUTTER_TYPE_ACTOR,
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER, G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
clutter_container_iface_init)) clutter_container_iface_init))
@ -2244,6 +2244,8 @@ clutter_stage_init (ClutterStage *self)
ClutterBackend *backend; ClutterBackend *backend;
GError *error; GError *error;
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_VISIBLE);
/* a stage is a top-level object */ /* a stage is a top-level object */
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_IS_TOPLEVEL); CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_IS_TOPLEVEL);

4
clutter/clutter-stage.h
View File

@ -55,7 +55,7 @@ typedef struct _ClutterStagePrivate ClutterStagePrivate;
struct _ClutterStage struct _ClutterStage
{ {
/*< private >*/ /*< private >*/
ClutterGroup parent_instance; ClutterActor parent_instance;
ClutterStagePrivate *priv; ClutterStagePrivate *priv;
}; };
@ -75,7 +75,7 @@ struct _ClutterStage
struct _ClutterStageClass struct _ClutterStageClass
{ {
/*< private >*/ /*< private >*/
ClutterGroupClass parent_class; ClutterActorClass parent_class;
/*< public >*/ /*< public >*/
/* signals */ /* signals */

44
clutter/clutter-swipe-action.c
View File

@ -142,7 +142,7 @@ gesture_end (ClutterGestureAction *action,
gfloat press_x, press_y; gfloat press_x, press_y;
gfloat release_x, release_y; gfloat release_x, release_y;
ClutterSwipeDirection direction = 0; ClutterSwipeDirection direction = 0;
gboolean can_emit_swipe; gboolean unused;
clutter_gesture_action_get_press_coords (action, clutter_gesture_action_get_press_coords (action,
0, 0,
@ -162,20 +162,8 @@ gesture_end (ClutterGestureAction *action,
else if (press_y - release_y > priv->threshold) else if (press_y - release_y > priv->threshold)
direction |= CLUTTER_SWIPE_DIRECTION_UP; direction |= CLUTTER_SWIPE_DIRECTION_UP;
/* XXX:2.0 remove */
g_signal_emit (action, swipe_signals[SWIPE], 0, actor, direction, g_signal_emit (action, swipe_signals[SWIPE], 0, actor, direction,
&can_emit_swipe); &unused);
if (can_emit_swipe)
g_signal_emit (action, swipe_signals[SWEPT], 0, actor, direction);
}
/* XXX:2.0 remove */
static gboolean
clutter_swipe_action_real_swipe (ClutterSwipeAction *action,
ClutterActor *actor,
ClutterSwipeDirection direction)
{
return TRUE;
} }
static void static void
@ -190,34 +178,6 @@ clutter_swipe_action_class_init (ClutterSwipeActionClass *klass)
gesture_class->gesture_progress = gesture_progress; gesture_class->gesture_progress = gesture_progress;
gesture_class->gesture_end = gesture_end; gesture_class->gesture_end = gesture_end;
/* XXX:2.0 remove */
klass->swipe = clutter_swipe_action_real_swipe;
/**
* ClutterSwipeAction::swept:
* @action: the #ClutterSwipeAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @direction: the main direction of the swipe gesture
*
* The ::swept signal is emitted when a swipe gesture is recognized on the
* attached actor.
*
* Deprecated: 1.14: Use the ::swipe signal instead.
*
* Since: 1.8
*/
swipe_signals[SWEPT] =
g_signal_new (I_("swept"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST |
G_SIGNAL_DEPRECATED,
G_STRUCT_OFFSET (ClutterSwipeActionClass, swept),
NULL, NULL,
_clutter_marshal_VOID__OBJECT_FLAGS,
G_TYPE_NONE, 2,
CLUTTER_TYPE_ACTOR,
CLUTTER_TYPE_SWIPE_DIRECTION);
/** /**
* ClutterSwipeAction::swipe: * ClutterSwipeAction::swipe:
* @action: the #ClutterSwipeAction that emitted the signal * @action: the #ClutterSwipeAction that emitted the signal