2010-05-11 14:04:34 +00:00
|
|
|
/*
|
|
|
|
* Clutter.
|
|
|
|
*
|
|
|
|
* An OpenGL based 'interactive canvas' library.
|
|
|
|
*
|
|
|
|
* Authored By Øyvind Kolås <pippin@linux.intel.com>
|
|
|
|
*
|
|
|
|
* Copyright (C) 2009 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/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* SECTION:clutter-state
|
|
|
|
* @short_description: State machine with animated transitions
|
|
|
|
*
|
2010-06-24 15:52:23 +00:00
|
|
|
* #ClutterState is an object controlling the tweening of properties on
|
|
|
|
* multiple actors between a set of named states. #ClutterStateKey<!-- -->s
|
|
|
|
* define how the properties are animated. If the source_state_name for a key
|
|
|
|
* is NULL it is used for transition to the target state unless a specific key
|
|
|
|
* exists for transitioning from the current state to the requested state.
|
2011-03-09 12:05:34 +00:00
|
|
|
*
|
|
|
|
* <example id="ClutterState-example">
|
|
|
|
* <title>A ClutterState example</title>
|
|
|
|
* <para>The following example defines a "base" and a "hover" state in a
|
|
|
|
* #ClutterState instance.</para>
|
|
|
|
* <programlisting>
|
|
|
|
* ClutterState *state = clutter_state_new ();
|
|
|
|
* ClutterColor color = { 0, };
|
|
|
|
*
|
|
|
|
* /* transition from any state to the "base" state */
|
|
|
|
* clutter_color_from_string (&color, "rgb(255, 0, 0)");
|
|
|
|
* clutter_state_set (state, NULL, "base",
|
|
|
|
* actor, "color", CLUTTER_LINEAR, &color,
|
|
|
|
* actor, "scale-x", CLUTTER_EASE_IN_BOUNCE, 1.0,
|
|
|
|
* actor, "scale-y", CLUTTER_EASE_IN_BOUNCE, 1.0,
|
|
|
|
* NULL);
|
|
|
|
*
|
|
|
|
* /* transition from the "base" state to the "hover" state */
|
|
|
|
* clutter_color_from_string (&color, "rgb(0, 0, 255)");
|
|
|
|
* clutter_state_set (state, "base", "hover",
|
|
|
|
* actor, "color", CLUTTER_LINEAR, &color,
|
|
|
|
* actor, "scale-x", CLUTTER_EASE_OUT_BOUNCE, 1.7,
|
|
|
|
* actor, "scale-y", CLUTTER_EASE_OUT_BOUNCE, 1.7,
|
|
|
|
* NULL);
|
|
|
|
*
|
|
|
|
* /* the default duration of any transition */
|
|
|
|
* clutter_state_set_duration (state, NULL, NULL, 500);
|
|
|
|
*
|
|
|
|
* /* set "base" as the initial state */
|
|
|
|
* clutter_state_warp_to_state (state, "base");
|
|
|
|
* </programlisting>
|
|
|
|
* <para>The actor then uses the #ClutterState to animate through the
|
|
|
|
* two states using callbacks for the #ClutterActor::enter-event and
|
|
|
|
* #ClutterActor::leave-event signals.</para>
|
|
|
|
* <programlisting>
|
|
|
|
* static gboolean
|
|
|
|
* on_enter (ClutterActor *actor,
|
|
|
|
* ClutterEvent *event,
|
|
|
|
* ClutterState *state)
|
|
|
|
* {
|
|
|
|
* clutter_state_set_state (state, "hover");
|
|
|
|
*
|
|
|
|
* return TRUE;
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* static gboolean
|
|
|
|
* on_leave (ClutterActor *actor,
|
|
|
|
* ClutterEvent *event,
|
|
|
|
* ClutterState *state)
|
|
|
|
* {
|
|
|
|
* clutter_state_set_state (state, "base");
|
|
|
|
*
|
|
|
|
* return TRUE;
|
|
|
|
* }
|
|
|
|
* </programlisting>
|
|
|
|
* </example>
|
|
|
|
*
|
|
|
|
* <refsect2 id="ClutterState-script">
|
|
|
|
* <title>ClutterState description for #ClutterScript</title>
|
|
|
|
* <para>#ClutterState defines a custom <emphasis>transitions</emphasis>
|
|
|
|
* property which allows describing the states.</para>
|
|
|
|
* <para>The <emphasis>transitions</emphasis> property has the following
|
|
|
|
* syntax:</para>
|
|
|
|
* <informalexample>
|
|
|
|
* <programlisting>
|
|
|
|
* {
|
|
|
|
* "transitions" : [
|
|
|
|
* {
|
|
|
|
* "source" : "<source-state>",
|
|
|
|
* "target" : "<target-state>",
|
|
|
|
* "duration" : <milliseconds>,
|
|
|
|
* "keys" : [
|
|
|
|
* [
|
|
|
|
* "<object-id>",
|
|
|
|
* "<property-name>",
|
|
|
|
* "<easing-mode>",
|
|
|
|
* "<final-value>",
|
|
|
|
* ],
|
|
|
|
* [
|
|
|
|
* "<object-id>",
|
|
|
|
* "<property-name>",
|
|
|
|
* "<easing-mode>",
|
|
|
|
* "<final-value>",
|
|
|
|
* <pre-delay>,
|
|
|
|
* <post-delay>
|
|
|
|
* ],
|
|
|
|
* ...
|
|
|
|
* ]
|
|
|
|
* },
|
|
|
|
* {
|
|
|
|
* "source" : "<source-state>",
|
|
|
|
* "target" : "<target-state>",
|
|
|
|
* "duration" : <milliseconds>,
|
|
|
|
* "animator" : "<animator-definition>"
|
|
|
|
* },
|
|
|
|
* ...
|
|
|
|
* ]
|
|
|
|
* }
|
|
|
|
* </programlisting>
|
|
|
|
* </informalexample>
|
|
|
|
* <para>Each element of the <emphasis>transitions</emphasis> array follows
|
|
|
|
* the same rules as clutter_state_set_key().</para>
|
|
|
|
* <para>The <emphasis>source</emphasis> and <emphasis>target</emphasis>
|
|
|
|
* values control the source and target state of the transition. The
|
|
|
|
* <emphasis>key</emphasis> and <emphasis>animator</emphasis> are mutually
|
|
|
|
* exclusive. The <emphasis>pre-delay</emphasis> and
|
|
|
|
* <emphasis>post-delay</emphasis> values are optional.</para>
|
|
|
|
* <example id="ClutterState-script-example">
|
|
|
|
* <title>ClutterState definition</title>
|
|
|
|
* <para>The example below is a translation into a #ClutterScript
|
|
|
|
* definition of the code in the <ulink linkend="ClutterState-example">example
|
|
|
|
* above</ulink>.</para>
|
|
|
|
* <programlisting>
|
|
|
|
* {
|
|
|
|
* "id" : "button-state",
|
|
|
|
* "type" : "ClutterState",
|
|
|
|
* "duration" : 500,
|
|
|
|
* "transitions" : [
|
|
|
|
* {
|
|
|
|
* "source" : "*",
|
|
|
|
* "target" : "base",
|
|
|
|
* "keys" : [
|
|
|
|
* [ "button", "color", "linear", "rgb(255, 0, 0)" ],
|
|
|
|
* [ "button", "scale-x", "easeInBounce", 1.0 ],
|
|
|
|
* [ "button", "scale-y", "easeInBounce", 1.0 ]
|
|
|
|
* ]
|
|
|
|
* },
|
|
|
|
* {
|
|
|
|
* "source" : "base",
|
|
|
|
* "target" : "hover",
|
|
|
|
* "keys" : [
|
|
|
|
* [ "button", "color", "linear", "rgb(0, 0, 255)" ],
|
|
|
|
* [ "button", "scale-x", "easeOutBounce", 1.7 ],
|
|
|
|
* [ "button", "scale-y", "easeOutBounce", 1.7 ]
|
|
|
|
* ]
|
|
|
|
* }
|
|
|
|
* ]
|
|
|
|
* }
|
|
|
|
* </programlisting>
|
|
|
|
* </example>
|
|
|
|
* </refsect2>
|
|
|
|
*
|
|
|
|
* #ClutterState is available since Clutter 1.4.
|
2012-04-11 17:30:40 +00:00
|
|
|
*
|
|
|
|
* #ClutterState has been deprecated in Clutter 1.12.
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "clutter-state.h"
|
2010-05-20 16:34:02 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
#include <gobject/gvaluecollector.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
2010-05-20 16:34:02 +00:00
|
|
|
#include "clutter-alpha.h"
|
2011-07-15 14:06:31 +00:00
|
|
|
#include "clutter-animatable.h"
|
2010-05-20 16:34:02 +00:00
|
|
|
#include "clutter-animator.h"
|
|
|
|
#include "clutter-enum-types.h"
|
|
|
|
#include "clutter-interval.h"
|
|
|
|
#include "clutter-marshal.h"
|
|
|
|
#include "clutter-private.h"
|
2010-05-21 13:13:14 +00:00
|
|
|
#include "clutter-scriptable.h"
|
|
|
|
#include "clutter-script-private.h"
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
typedef struct StateAnimator {
|
2010-05-20 22:05:16 +00:00
|
|
|
const gchar *source_state_name; /* interned string identifying entry */
|
|
|
|
ClutterAnimator *animator; /* pointer to animator itself */
|
2010-05-11 14:04:34 +00:00
|
|
|
} StateAnimator;
|
|
|
|
|
2010-05-20 22:05:16 +00:00
|
|
|
typedef struct State
|
|
|
|
{
|
|
|
|
const gchar *name; /* interned string for this state name */
|
|
|
|
GHashTable *durations; /* durations for transitions from various state
|
|
|
|
names */
|
|
|
|
GList *keys; /* list of all keys pertaining to transitions
|
|
|
|
from other states to this one */
|
|
|
|
GArray *animators; /* list of animators for transitioning from
|
|
|
|
* specific source states */
|
|
|
|
ClutterState *clutter_state; /* the ClutterState object this state belongs to
|
|
|
|
*/
|
2010-05-11 14:04:34 +00:00
|
|
|
} State;
|
|
|
|
|
|
|
|
struct _ClutterStatePrivate
|
|
|
|
{
|
2010-05-20 22:05:16 +00:00
|
|
|
GHashTable *states; /* contains state objects */
|
|
|
|
guint duration; /* global fallback duration */
|
|
|
|
ClutterTimeline *timeline; /* The timeline used for doing the
|
|
|
|
progress */
|
|
|
|
ClutterTimeline *slave_timeline; /* a slave timeline used to compute
|
|
|
|
alphas */
|
|
|
|
const gchar *source_state_name; /* current source state */
|
|
|
|
State *source_state; /* current source_state */
|
|
|
|
const gchar *target_state_name; /* current target state */
|
|
|
|
State *target_state; /* target state name */
|
|
|
|
ClutterAnimator *current_animator; /* !NULL if the current transition is
|
|
|
|
overriden by an animator */
|
2010-05-11 14:04:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define SLAVE_TIMELINE_LENGTH 10000
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
/*
|
2010-05-11 14:04:34 +00:00
|
|
|
* ClutterStateKey:
|
|
|
|
*
|
|
|
|
* An opaque data structure with accessor functions.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
typedef struct _ClutterStateKey
|
|
|
|
{
|
2010-05-20 22:05:16 +00:00
|
|
|
GObject *object; /* an Gobject */
|
|
|
|
const gchar *property_name;/* the name of a property */
|
|
|
|
gulong mode; /* alpha to use */
|
|
|
|
GValue value; /* target value */
|
|
|
|
gdouble pre_delay; /* fraction of duration to delay before
|
|
|
|
starting */
|
2010-10-22 15:13:16 +00:00
|
|
|
gdouble pre_pre_delay;/* fraction of duration to add to
|
|
|
|
pre_delay. This is used to set keys
|
|
|
|
during transitions. */
|
2010-05-20 22:05:16 +00:00
|
|
|
gdouble post_delay; /* fraction of duration to be done in */
|
|
|
|
|
|
|
|
State *source_state; /* source state */
|
|
|
|
State *target_state; /* target state */
|
|
|
|
|
|
|
|
ClutterAlpha *alpha; /* The alpha this key uses for interpolation */
|
|
|
|
ClutterInterval *interval; /* The interval this key uses for
|
|
|
|
interpolation */
|
|
|
|
|
2011-07-15 14:06:31 +00:00
|
|
|
guint is_animatable : 1;
|
2010-05-20 22:05:16 +00:00
|
|
|
guint is_inert : 1; /* set if the key is being destroyed due to
|
|
|
|
weak reference */
|
|
|
|
gint ref_count; /* reference count for boxed life time */
|
2010-05-11 14:04:34 +00:00
|
|
|
} _ClutterStateKey;
|
|
|
|
|
2010-05-21 09:37:42 +00:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
PROP_0,
|
2010-06-16 16:33:48 +00:00
|
|
|
PROP_DURATION,
|
2010-06-21 09:20:32 +00:00
|
|
|
PROP_STATE,
|
|
|
|
|
|
|
|
PROP_LAST
|
2010-05-21 09:37:42 +00:00
|
|
|
};
|
|
|
|
|
2010-06-21 09:20:32 +00:00
|
|
|
static GParamSpec *obj_props[PROP_LAST];
|
|
|
|
|
2010-05-12 16:03:25 +00:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
COMPLETED,
|
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
2010-05-21 13:13:14 +00:00
|
|
|
static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);
|
|
|
|
|
2010-05-12 16:03:25 +00:00
|
|
|
static guint state_signals[LAST_SIGNAL] = {0, };
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
#define CLUTTER_STATE_GET_PRIVATE(obj) \
|
|
|
|
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
|
|
|
|
CLUTTER_TYPE_STATE, \
|
|
|
|
ClutterStatePrivate))
|
|
|
|
|
2010-05-21 13:13:14 +00:00
|
|
|
G_DEFINE_TYPE_WITH_CODE (ClutterState, clutter_state, G_TYPE_OBJECT,
|
|
|
|
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_SCRIPTABLE,
|
|
|
|
clutter_scriptable_iface_init));
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
/**
|
|
|
|
* clutter_state_new:
|
|
|
|
*
|
2010-05-20 17:34:34 +00:00
|
|
|
* Creates a new #ClutterState
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
2010-05-20 17:34:34 +00:00
|
|
|
* Return value: the newly create #ClutterState instance
|
2012-04-11 17:30:40 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
ClutterState *
|
|
|
|
clutter_state_new (void)
|
|
|
|
{
|
|
|
|
return g_object_new (CLUTTER_TYPE_STATE, NULL);
|
|
|
|
}
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
static gint
|
|
|
|
sort_props_func (gconstpointer a,
|
|
|
|
gconstpointer b)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
const ClutterStateKey *pa = a;
|
|
|
|
const ClutterStateKey *pb = b;
|
|
|
|
|
|
|
|
if (pa->object == pb->object)
|
|
|
|
{
|
|
|
|
gint propnamediff = pa->property_name-pb->property_name;
|
|
|
|
if (propnamediff == 0)
|
2010-05-20 17:34:34 +00:00
|
|
|
return pb->source_state - pa->source_state;
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return propnamediff;
|
|
|
|
}
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return pa->object - pb->object;
|
|
|
|
}
|
|
|
|
|
2010-07-02 15:44:54 +00:00
|
|
|
static State * clutter_state_fetch_state (ClutterState *state,
|
|
|
|
const gchar *state_name,
|
|
|
|
gboolean force_creation);
|
2010-05-11 14:04:34 +00:00
|
|
|
static void object_disappeared (gpointer data,
|
|
|
|
GObject *where_the_object_was);
|
|
|
|
|
|
|
|
static ClutterStateKey *
|
|
|
|
clutter_state_key_new (State *state,
|
|
|
|
GObject *object,
|
|
|
|
const gchar *property_name,
|
2010-05-20 17:34:34 +00:00
|
|
|
GParamSpec *pspec,
|
2010-05-11 14:04:34 +00:00
|
|
|
guint mode)
|
|
|
|
{
|
2010-05-26 12:43:42 +00:00
|
|
|
ClutterStatePrivate *priv = state->clutter_state->priv;
|
2010-05-11 14:04:34 +00:00
|
|
|
ClutterStateKey *state_key;
|
2012-03-17 16:38:06 +00:00
|
|
|
GValue value = G_VALUE_INIT;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
state_key = g_slice_new0 (ClutterStateKey);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
state_key->target_state = state;
|
|
|
|
state_key->object = object;
|
|
|
|
state_key->property_name = g_intern_string (property_name);
|
|
|
|
state_key->mode = mode;
|
2011-07-15 14:06:31 +00:00
|
|
|
state_key->is_animatable = CLUTTER_IS_ANIMATABLE (object);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
state_key->alpha = clutter_alpha_new ();
|
2010-05-20 17:34:34 +00:00
|
|
|
g_object_ref_sink (state_key->alpha);
|
2010-05-11 14:04:34 +00:00
|
|
|
clutter_alpha_set_mode (state_key->alpha, mode);
|
2010-05-26 12:43:42 +00:00
|
|
|
clutter_alpha_set_timeline (state_key->alpha, priv->slave_timeline);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
state_key->interval =
|
2010-05-20 17:34:34 +00:00
|
|
|
g_object_new (CLUTTER_TYPE_INTERVAL,
|
|
|
|
"value-type", G_PARAM_SPEC_VALUE_TYPE (pspec),
|
|
|
|
NULL);
|
|
|
|
g_object_ref_sink (state_key->interval);
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
|
|
|
|
clutter_interval_set_initial_value (state_key->interval, &value);
|
|
|
|
clutter_interval_set_final_value (state_key->interval, &value);
|
|
|
|
g_value_unset (&value);
|
|
|
|
|
|
|
|
g_object_weak_ref (object, object_disappeared,
|
2010-05-20 22:05:16 +00:00
|
|
|
state_key->target_state->clutter_state);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
return state_key;
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_state_key_free (gpointer clutter_state_key)
|
|
|
|
{
|
|
|
|
ClutterStateKey *key = clutter_state_key;
|
|
|
|
|
|
|
|
if (key == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
key->ref_count -= 1;
|
|
|
|
|
|
|
|
if (key->ref_count > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!key->is_inert)
|
2010-05-26 12:43:42 +00:00
|
|
|
{
|
|
|
|
g_object_weak_unref (key->object,
|
|
|
|
object_disappeared,
|
|
|
|
key->target_state->clutter_state);
|
|
|
|
}
|
|
|
|
|
2010-08-13 11:12:59 +00:00
|
|
|
g_value_unset (&key->value);
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
g_object_unref (key->alpha);
|
|
|
|
g_object_unref (key->interval);
|
|
|
|
|
|
|
|
g_slice_free (ClutterStateKey, key);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
static inline void
|
2010-05-11 14:04:34 +00:00
|
|
|
clutter_state_remove_key_internal (ClutterState *this,
|
2010-05-20 17:34:34 +00:00
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name,
|
|
|
|
GObject *object,
|
|
|
|
const gchar *property_name,
|
|
|
|
gboolean is_inert)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
GList *s, *state_list;
|
|
|
|
State *source_state = NULL;
|
|
|
|
|
|
|
|
source_state_name = g_intern_string (source_state_name);
|
|
|
|
target_state_name = g_intern_string (target_state_name);
|
|
|
|
property_name = g_intern_string (property_name);
|
|
|
|
|
|
|
|
if (source_state_name)
|
2010-07-02 15:44:54 +00:00
|
|
|
source_state = clutter_state_fetch_state (this, source_state_name, FALSE);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-08-17 12:22:08 +00:00
|
|
|
again_from_start:
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
if (target_state_name != NULL)
|
2010-05-20 17:34:34 +00:00
|
|
|
state_list = g_list_append (NULL, (gpointer) target_state_name);
|
2010-05-11 14:04:34 +00:00
|
|
|
else
|
2010-05-20 17:34:34 +00:00
|
|
|
state_list = clutter_state_get_states (this);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
for (s = state_list; s != NULL; s = s->next)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
State *target_state;
|
2010-07-02 15:44:54 +00:00
|
|
|
target_state = clutter_state_fetch_state (this, s->data, FALSE);
|
2010-08-17 12:22:08 +00:00
|
|
|
/* Go through each TargetState */
|
2010-05-11 14:04:34 +00:00
|
|
|
if (target_state)
|
|
|
|
{
|
2012-01-29 12:29:38 +00:00
|
|
|
GList *k = target_state->keys;
|
|
|
|
|
|
|
|
/* Note the safe while() loop, because we modify the list inline */
|
|
|
|
while (k != NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 17:34:34 +00:00
|
|
|
ClutterStateKey *key = k->data;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2012-01-29 12:29:38 +00:00
|
|
|
k = k->next;
|
|
|
|
|
2010-08-17 12:22:08 +00:00
|
|
|
/* Check if each key matches query */
|
2010-07-06 12:34:22 +00:00
|
|
|
if ( (object == NULL || (object == key->object))
|
|
|
|
&& (source_state == NULL || (source_state == key->source_state))
|
|
|
|
&& (property_name == NULL || ((property_name == key->property_name))))
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-08-17 12:22:08 +00:00
|
|
|
/* Remove matching key */
|
2010-07-06 12:34:22 +00:00
|
|
|
target_state->keys = g_list_remove (target_state->keys, key);
|
2010-08-17 12:22:08 +00:00
|
|
|
key->is_inert = is_inert;
|
|
|
|
clutter_state_key_free (key);
|
2010-07-06 12:34:22 +00:00
|
|
|
|
2010-08-17 12:22:08 +00:00
|
|
|
/* no more keys with transitions to this target_state*/
|
2010-07-06 12:34:22 +00:00
|
|
|
if (target_state->keys == NULL)
|
|
|
|
{
|
2010-10-22 14:24:49 +00:00
|
|
|
/* If this state is the current state, unset the state */
|
|
|
|
if (target_state == this->priv->target_state)
|
|
|
|
clutter_state_set_state (this, NULL);
|
|
|
|
|
2010-08-17 12:22:08 +00:00
|
|
|
/* remove any keys that exist that uses this state as a source */
|
2012-01-29 12:29:38 +00:00
|
|
|
clutter_state_remove_key_internal (this, s->data, NULL, NULL, NULL, is_inert);
|
2010-08-17 12:22:08 +00:00
|
|
|
|
2010-07-06 12:34:22 +00:00
|
|
|
g_hash_table_remove (this->priv->states, s->data);
|
2010-08-17 12:22:08 +00:00
|
|
|
goto again_from_start; /* we have just freed State *target_state, so
|
|
|
|
need to restart removal */
|
2010-07-06 12:34:22 +00:00
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
g_list_free (state_list);
|
|
|
|
}
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
static void
|
|
|
|
object_disappeared (gpointer data,
|
|
|
|
GObject *where_the_object_was)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
clutter_state_remove_key_internal (data, NULL, NULL,
|
2010-05-20 17:34:34 +00:00
|
|
|
(gpointer) where_the_object_was,
|
|
|
|
NULL,
|
|
|
|
TRUE);
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
static void
|
|
|
|
state_free (gpointer data)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
State *state = data;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
for (; state->keys;
|
|
|
|
state->keys = g_list_remove (state->keys, state->keys->data))
|
|
|
|
clutter_state_key_free (state->keys->data);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-06-18 14:19:59 +00:00
|
|
|
g_array_free (state->animators, TRUE);
|
2010-05-11 14:04:34 +00:00
|
|
|
g_hash_table_destroy (state->durations);
|
|
|
|
g_free (state);
|
|
|
|
}
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
static State *
|
2010-05-20 22:05:16 +00:00
|
|
|
state_new (ClutterState *clutter_state,
|
2010-05-20 17:34:34 +00:00
|
|
|
const gchar *name)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
State *state;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
state = g_new0 (State, 1);
|
2010-05-20 22:05:16 +00:00
|
|
|
state->clutter_state = clutter_state;
|
2010-05-11 14:04:34 +00:00
|
|
|
state->name = name;
|
|
|
|
state->animators = g_array_new (TRUE, TRUE, sizeof (StateAnimator));
|
|
|
|
state->durations = g_hash_table_new (g_direct_hash, g_direct_equal);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_state_finalize (GObject *object)
|
|
|
|
{
|
2010-05-20 17:34:34 +00:00
|
|
|
ClutterStatePrivate *priv = CLUTTER_STATE (object)->priv;
|
|
|
|
|
|
|
|
g_hash_table_destroy (priv->states);
|
|
|
|
|
|
|
|
g_object_unref (priv->timeline);
|
|
|
|
g_object_unref (priv->slave_timeline);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
G_OBJECT_CLASS (clutter_state_parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
static void
|
|
|
|
clutter_state_completed (ClutterTimeline *timeline,
|
|
|
|
ClutterState *state)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 17:34:34 +00:00
|
|
|
ClutterStatePrivate *priv = state->priv;
|
|
|
|
|
|
|
|
if (priv->current_animator)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 17:34:34 +00:00
|
|
|
clutter_animator_set_timeline (priv->current_animator, NULL);
|
|
|
|
priv->current_animator = NULL;
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-12 16:03:25 +00:00
|
|
|
g_signal_emit (state, state_signals[COMPLETED], 0);
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
static void
|
|
|
|
clutter_state_new_frame (ClutterTimeline *timeline,
|
|
|
|
gint msecs,
|
|
|
|
ClutterState *state)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-24 14:14:09 +00:00
|
|
|
ClutterStatePrivate *priv = state->priv;
|
|
|
|
GList *k;
|
|
|
|
gdouble progress;
|
2010-05-11 14:04:34 +00:00
|
|
|
const gchar *curprop = NULL;
|
2010-05-24 14:14:09 +00:00
|
|
|
GObject *curobj = NULL;
|
|
|
|
gboolean found_specific = FALSE;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-24 14:14:09 +00:00
|
|
|
if (priv->current_animator)
|
2010-05-11 14:04:34 +00:00
|
|
|
return;
|
|
|
|
|
2010-05-20 14:41:29 +00:00
|
|
|
progress = clutter_timeline_get_progress (timeline);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-24 14:14:09 +00:00
|
|
|
for (k = priv->target_state->keys; k; k = k->next)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
ClutterStateKey *key = k->data;
|
2010-05-24 14:14:09 +00:00
|
|
|
gdouble sub_progress;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
if ((curprop && !(curprop == key->property_name)) ||
|
|
|
|
key->object != curobj)
|
|
|
|
{
|
|
|
|
curprop = key->property_name;
|
|
|
|
curobj = key->object;
|
|
|
|
found_specific = FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found_specific)
|
|
|
|
{
|
2010-05-24 14:14:09 +00:00
|
|
|
if (key->source_state != NULL &&
|
|
|
|
key->source_state->name != NULL &&
|
2010-06-25 01:02:48 +00:00
|
|
|
priv->source_state_name != NULL &&
|
2010-05-24 14:14:09 +00:00
|
|
|
g_str_equal (priv->source_state_name, key->source_state->name))
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
found_specific = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found_specific || key->source_state == NULL)
|
|
|
|
{
|
2010-10-22 15:13:16 +00:00
|
|
|
gdouble pre_delay = key->pre_delay + key->pre_pre_delay;
|
2010-05-24 14:14:09 +00:00
|
|
|
|
2011-07-15 14:06:31 +00:00
|
|
|
sub_progress = (progress - pre_delay)
|
|
|
|
/ (1.0 - (pre_delay + key->post_delay));
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
if (sub_progress >= 0.0)
|
|
|
|
{
|
|
|
|
if (sub_progress >= 1.0)
|
|
|
|
sub_progress = 1.0;
|
2010-05-24 14:14:09 +00:00
|
|
|
|
|
|
|
clutter_timeline_advance (priv->slave_timeline,
|
2010-05-11 14:04:34 +00:00
|
|
|
sub_progress * SLAVE_TIMELINE_LENGTH);
|
|
|
|
sub_progress = clutter_alpha_get_alpha (key->alpha);
|
|
|
|
|
2011-07-15 14:06:31 +00:00
|
|
|
if (key->is_animatable)
|
|
|
|
{
|
|
|
|
ClutterAnimatable *animatable;
|
2012-03-17 16:38:06 +00:00
|
|
|
GValue value = G_VALUE_INIT;
|
2011-07-15 14:06:31 +00:00
|
|
|
gboolean res;
|
|
|
|
|
|
|
|
animatable = CLUTTER_ANIMATABLE (key->object);
|
|
|
|
|
|
|
|
g_value_init (&value, clutter_state_key_get_property_type (key));
|
|
|
|
|
|
|
|
res =
|
|
|
|
clutter_animatable_interpolate_value (animatable,
|
|
|
|
key->property_name,
|
|
|
|
key->interval,
|
|
|
|
sub_progress,
|
|
|
|
&value);
|
|
|
|
|
|
|
|
if (res)
|
|
|
|
clutter_animatable_set_final_state (animatable,
|
|
|
|
key->property_name,
|
|
|
|
&value);
|
|
|
|
|
|
|
|
g_value_unset (&value);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const GValue *value;
|
|
|
|
|
|
|
|
value = clutter_interval_compute (key->interval, sub_progress);
|
|
|
|
if (value != NULL)
|
|
|
|
g_object_set_property (key->object, key->property_name, value);
|
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
2010-05-24 14:14:09 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
/* XXX: should the target value of the default destination be
|
|
|
|
* used even when found a specific source_state key?
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-07 17:14:43 +00:00
|
|
|
static ClutterTimeline *
|
2010-05-24 13:20:23 +00:00
|
|
|
clutter_state_change (ClutterState *state,
|
2010-05-20 15:13:46 +00:00
|
|
|
const gchar *target_state_name,
|
|
|
|
gboolean animate)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-24 13:20:23 +00:00
|
|
|
ClutterStatePrivate *priv;
|
2010-05-24 15:10:00 +00:00
|
|
|
ClutterAnimator *animator;
|
|
|
|
State *new_state;
|
|
|
|
guint duration;
|
|
|
|
GList *k;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STATE (state), NULL);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
priv = state->priv;
|
|
|
|
|
2010-10-21 15:51:45 +00:00
|
|
|
/* If we've been asked to change state to NULL, reset the
|
|
|
|
* ClutterState to its initial state, but leave the keys
|
|
|
|
* alone.
|
|
|
|
*/
|
|
|
|
if (!target_state_name)
|
|
|
|
{
|
2010-10-22 15:13:16 +00:00
|
|
|
if (!priv->target_state)
|
|
|
|
return NULL;
|
|
|
|
|
2010-10-21 15:51:45 +00:00
|
|
|
priv->source_state_name = priv->target_state_name = NULL;
|
2010-10-22 15:13:16 +00:00
|
|
|
priv->source_state = priv->target_state = NULL;
|
|
|
|
|
2010-10-21 15:51:45 +00:00
|
|
|
clutter_timeline_stop (priv->timeline);
|
|
|
|
clutter_timeline_rewind (priv->timeline);
|
2010-10-22 15:13:16 +00:00
|
|
|
|
|
|
|
if (priv->current_animator)
|
|
|
|
{
|
|
|
|
clutter_animator_set_timeline (priv->current_animator, NULL);
|
|
|
|
priv->current_animator = NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-21 15:51:45 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-22 15:13:16 +00:00
|
|
|
target_state_name = g_intern_string (target_state_name);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
if (target_state_name == priv->target_state_name)
|
|
|
|
{
|
2010-10-22 15:32:05 +00:00
|
|
|
/* Avoid transitioning if the desired state is already current,
|
|
|
|
* unless we're warping to it and the state transition is in
|
|
|
|
* progress (in that case, immediately warp to the state).
|
|
|
|
*/
|
|
|
|
if (!clutter_timeline_is_playing (priv->timeline) || animate)
|
|
|
|
return priv->timeline;
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
if (priv->current_animator != NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
clutter_animator_set_timeline (priv->current_animator, NULL);
|
|
|
|
priv->current_animator = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->source_state_name = priv->target_state_name;
|
|
|
|
priv->target_state_name = target_state_name;
|
|
|
|
|
2011-03-03 11:35:46 +00:00
|
|
|
g_object_notify_by_pspec (G_OBJECT (state), obj_props[PROP_STATE]);
|
2010-05-21 09:37:42 +00:00
|
|
|
|
2010-05-24 15:10:00 +00:00
|
|
|
duration = clutter_state_get_duration (state,
|
|
|
|
priv->source_state_name,
|
|
|
|
priv->target_state_name);
|
|
|
|
clutter_timeline_set_duration (priv->timeline, duration);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-07-02 15:44:54 +00:00
|
|
|
new_state = clutter_state_fetch_state (state, target_state_name, FALSE);
|
2010-05-24 13:20:23 +00:00
|
|
|
if (new_state == NULL)
|
|
|
|
{
|
|
|
|
g_warning ("State '%s' not found", target_state_name);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
animator = clutter_state_get_animator (state,
|
|
|
|
priv->source_state_name,
|
|
|
|
priv->target_state_name);
|
2010-05-24 15:10:00 +00:00
|
|
|
priv->target_state = new_state;
|
|
|
|
|
2010-09-17 11:21:03 +00:00
|
|
|
if (animator == NULL && new_state->keys == NULL)
|
|
|
|
animator = clutter_state_get_animator (state, NULL,
|
|
|
|
priv->target_state_name);
|
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
if (animator != NULL)
|
2010-05-26 12:43:42 +00:00
|
|
|
{
|
|
|
|
/* we've got an animator overriding the tweened animation */
|
2010-05-24 13:20:23 +00:00
|
|
|
priv->current_animator = animator;
|
|
|
|
clutter_animator_set_timeline (animator, priv->timeline);
|
|
|
|
}
|
2010-05-24 15:10:00 +00:00
|
|
|
else
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-24 15:10:00 +00:00
|
|
|
for (k = new_state->keys; k != NULL; k = k->next)
|
|
|
|
{
|
|
|
|
ClutterStateKey *key = k->data;
|
2012-03-17 16:38:06 +00:00
|
|
|
GValue initial = G_VALUE_INIT;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-10-22 15:13:16 +00:00
|
|
|
/* Reset the pre-pre-delay - this is only used for setting keys
|
|
|
|
* during transitions.
|
|
|
|
*/
|
|
|
|
key->pre_pre_delay = 0;
|
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
g_value_init (&initial, clutter_interval_get_value_type (key->interval));
|
2011-07-15 14:06:31 +00:00
|
|
|
|
|
|
|
if (key->is_animatable)
|
|
|
|
{
|
|
|
|
ClutterAnimatable *animatable;
|
|
|
|
|
|
|
|
animatable = CLUTTER_ANIMATABLE (key->object);
|
|
|
|
clutter_animatable_get_initial_state (animatable,
|
|
|
|
key->property_name,
|
|
|
|
&initial);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
g_object_get_property (key->object, key->property_name, &initial);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-24 15:10:00 +00:00
|
|
|
if (clutter_alpha_get_mode (key->alpha) != key->mode)
|
|
|
|
clutter_alpha_set_mode (key->alpha, key->mode);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-24 15:10:00 +00:00
|
|
|
clutter_interval_set_initial_value (key->interval, &initial);
|
|
|
|
clutter_interval_set_final_value (key->interval, &key->value);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-24 15:10:00 +00:00
|
|
|
g_value_unset (&initial);
|
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
2010-05-24 13:20:23 +00:00
|
|
|
|
2010-05-24 15:10:00 +00:00
|
|
|
if (!animate)
|
|
|
|
{
|
|
|
|
clutter_timeline_stop (priv->timeline);
|
|
|
|
clutter_timeline_advance (priv->timeline, duration);
|
|
|
|
|
|
|
|
/* emit signals, to change properties, and indicate that the
|
|
|
|
* state change is complete */
|
|
|
|
g_signal_emit_by_name (priv->timeline, "new-frame",
|
2010-05-26 12:43:42 +00:00
|
|
|
GINT_TO_POINTER (duration),
|
|
|
|
NULL);
|
2010-05-24 15:10:00 +00:00
|
|
|
g_signal_emit_by_name (priv->timeline, "completed", NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
clutter_timeline_stop (priv->timeline);
|
|
|
|
clutter_timeline_rewind (priv->timeline);
|
|
|
|
clutter_timeline_start (priv->timeline);
|
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
return priv->timeline;
|
|
|
|
}
|
|
|
|
|
2010-07-07 17:14:43 +00:00
|
|
|
/**
|
|
|
|
* clutter_state_set_state:
|
|
|
|
* @state: a #ClutterState
|
|
|
|
* @target_state_name: the state to transition to
|
|
|
|
*
|
2010-10-21 15:51:45 +00:00
|
|
|
* Change the current state of #ClutterState to @target_state_name.
|
2010-07-07 17:14:43 +00:00
|
|
|
*
|
|
|
|
* The state will animate during its transition, see
|
|
|
|
* #clutter_state_warp_to_state for animation-free state switching.
|
|
|
|
*
|
2010-10-21 15:51:45 +00:00
|
|
|
* Setting a %NULL state will stop the current animation and unset
|
|
|
|
* the current state, but keys will be left intact.
|
|
|
|
*
|
2010-09-03 11:14:50 +00:00
|
|
|
* Return value: (transfer none): the #ClutterTimeline that drives the
|
|
|
|
* state transition. The returned timeline is owned by the #ClutterState
|
|
|
|
* and it should not be unreferenced
|
2010-07-07 17:14:43 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-07-07 17:14:43 +00:00
|
|
|
*/
|
|
|
|
ClutterTimeline *
|
|
|
|
clutter_state_set_state (ClutterState *state,
|
|
|
|
const gchar *target_state_name)
|
|
|
|
{
|
2010-07-12 16:34:17 +00:00
|
|
|
return clutter_state_change (state, target_state_name, TRUE);
|
2010-07-07 17:14:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_warp_to_state:
|
|
|
|
* @state: a #ClutterState
|
|
|
|
* @target_state_name: the state to transition to
|
|
|
|
*
|
|
|
|
* Change to the specified target state immediately with no animation.
|
|
|
|
*
|
2010-10-21 15:51:45 +00:00
|
|
|
* See clutter_state_set_state().
|
|
|
|
*
|
2010-09-03 11:14:50 +00:00
|
|
|
* Return value: (transfer none): the #ClutterTimeline that drives the
|
|
|
|
* state transition. The returned timeline is owned by the #ClutterState
|
|
|
|
* and it should not be unreferenced
|
2010-07-07 17:14:43 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-07-07 17:14:43 +00:00
|
|
|
*/
|
|
|
|
ClutterTimeline *
|
|
|
|
clutter_state_warp_to_state (ClutterState *state,
|
|
|
|
const gchar *target_state_name)
|
|
|
|
{
|
2010-07-12 16:34:17 +00:00
|
|
|
return clutter_state_change (state, target_state_name, FALSE);
|
2010-07-07 17:14:43 +00:00
|
|
|
}
|
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
static GParamSpec *
|
|
|
|
get_property_from_object (GObject *gobject,
|
|
|
|
const gchar *property_name)
|
|
|
|
{
|
|
|
|
GParamSpec *pspec;
|
|
|
|
|
2011-07-15 14:06:31 +00:00
|
|
|
if (CLUTTER_IS_ANIMATABLE (gobject))
|
|
|
|
{
|
|
|
|
ClutterAnimatable *animatable = CLUTTER_ANIMATABLE (gobject);
|
|
|
|
|
|
|
|
pspec = clutter_animatable_find_property (animatable, property_name);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GObjectClass *klass = G_OBJECT_GET_CLASS (gobject);
|
|
|
|
|
|
|
|
pspec = g_object_class_find_property (klass, property_name);
|
|
|
|
}
|
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
if (pspec == NULL)
|
|
|
|
{
|
|
|
|
g_warning ("Cannot bind property '%s': objects of type '%s' "
|
|
|
|
"do not have this property",
|
|
|
|
property_name,
|
|
|
|
G_OBJECT_TYPE_NAME (gobject));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(pspec->flags & G_PARAM_WRITABLE))
|
|
|
|
{
|
|
|
|
g_warning ("Cannot bind property '%s' of object of type '%s': "
|
|
|
|
"the property is not writable",
|
|
|
|
property_name,
|
|
|
|
G_OBJECT_TYPE_NAME (gobject));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(pspec->flags & G_PARAM_READABLE))
|
|
|
|
{
|
|
|
|
g_warning ("Cannot bind property '%s' of object of type '%s': "
|
|
|
|
"the property is not readable",
|
|
|
|
property_name,
|
|
|
|
G_OBJECT_TYPE_NAME (gobject));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pspec->flags & G_PARAM_CONSTRUCT_ONLY)
|
|
|
|
{
|
|
|
|
g_warning ("Cannot bind property '%s' of object of type '%s': "
|
|
|
|
"the property is set as constructor-only",
|
|
|
|
property_name,
|
|
|
|
G_OBJECT_TYPE_NAME (gobject));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pspec;
|
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_set:
|
|
|
|
* @state: a #ClutterState instance.
|
2011-10-05 20:03:25 +00:00
|
|
|
* @source_state_name: (allow-none): the name of the source state keys are being added for
|
2010-05-20 17:57:27 +00:00
|
|
|
* @target_state_name: the name of the target state keys are being added for
|
2010-05-11 14:04:34 +00:00
|
|
|
* @first_object: a #GObject
|
2010-05-20 17:57:27 +00:00
|
|
|
* @first_property_name: a property of @first_object to specify a key for
|
2010-05-11 14:04:34 +00:00
|
|
|
* @first_mode: the id of the alpha function to use
|
2011-07-26 12:43:37 +00:00
|
|
|
* @...: the value @first_property_name should have in @target_state_name,
|
2010-05-20 17:57:27 +00:00
|
|
|
* followed by object, property name, mode, value tuples, terminated
|
|
|
|
* by %NULL
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Adds multiple keys to a named state of a #ClutterState instance, specifying
|
|
|
|
* the easing mode and value a given property of an object should have at a
|
2010-05-20 17:57:27 +00:00
|
|
|
* given progress of the animation.
|
|
|
|
*
|
|
|
|
* The mode specified is the easing mode used when going to from the previous
|
|
|
|
* key to the specified key.
|
|
|
|
*
|
2010-05-26 12:43:42 +00:00
|
|
|
* For instance, the code below:
|
|
|
|
*
|
|
|
|
* |[
|
2010-06-24 01:26:46 +00:00
|
|
|
* clutter_state_set (state, NULL, "hover",
|
2010-10-22 16:41:06 +00:00
|
|
|
* button, "opacity", CLUTTER_LINEAR, 255,
|
|
|
|
* button, "scale-x", CLUTTER_EASE_OUT_CUBIC, 1.2,
|
|
|
|
* button, "scale-y", CLUTTER_EASE_OUT_CUBIC, 1.2,
|
2010-05-26 12:43:42 +00:00
|
|
|
* NULL);
|
|
|
|
* ]|
|
|
|
|
*
|
2011-10-05 20:03:25 +00:00
|
|
|
* will create a transition from any state (a @source_state_name or NULL is
|
2010-06-24 01:26:46 +00:00
|
|
|
* treated as a wildcard) and a state named "hover"; the
|
2010-05-26 12:43:42 +00:00
|
|
|
* <emphasis>button</emphasis> object will have the #ClutterActor:opacity
|
|
|
|
* property animated to a value of 255 using %CLUTTER_LINEAR as the animation
|
|
|
|
* mode, and the #ClutterActor:scale-x and #ClutterActor:scale-y properties
|
|
|
|
* animated to a value of 1.2 using %CLUTTER_EASE_OUT_CUBIC as the animation
|
|
|
|
* mode. To change the state (and start the transition) you can use the
|
2010-10-22 16:41:06 +00:00
|
|
|
* clutter_state_set_state() function:
|
2010-05-26 12:43:42 +00:00
|
|
|
*
|
|
|
|
* |[
|
2010-10-22 16:41:06 +00:00
|
|
|
* clutter_state_set_state (state, "hover");
|
2010-05-26 12:43:42 +00:00
|
|
|
* ]|
|
|
|
|
*
|
|
|
|
* If a given object, state_name, property tuple already exist in the
|
|
|
|
* #ClutterState instance, then the mode and value will be replaced with
|
|
|
|
* the new specified values.
|
|
|
|
*
|
|
|
|
* If a property name is prefixed with "delayed::" two additional
|
2010-05-20 17:57:27 +00:00
|
|
|
* arguments per key are expected: a value relative to the full state time
|
|
|
|
* to pause before transitioning and a similar value to pause after
|
2010-05-26 12:43:42 +00:00
|
|
|
* transitioning, e.g.:
|
|
|
|
*
|
|
|
|
* |[
|
|
|
|
* clutter_state_set (state, "hover", "toggled",
|
2010-10-22 16:41:06 +00:00
|
|
|
* button, "delayed::scale-x", CLUTTER_LINEAR, 1.0, 0.2, 0.2,
|
|
|
|
* button, "delayed::scale-y", CLUTTER_LINEAR, 1.0, 0.2, 0.2,
|
2010-05-26 12:43:42 +00:00
|
|
|
* NULL);
|
|
|
|
* ]|
|
|
|
|
*
|
|
|
|
* will pause for 20% of the duration of the transition before animating,
|
|
|
|
* and 20% of the duration after animating.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_state_set (ClutterState *state,
|
2010-05-21 09:37:42 +00:00
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name,
|
|
|
|
gpointer first_object,
|
|
|
|
const gchar *first_property_name,
|
|
|
|
gulong first_mode,
|
2010-05-20 17:34:34 +00:00
|
|
|
...)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-26 12:43:42 +00:00
|
|
|
gpointer object;
|
|
|
|
const gchar *property_name;
|
|
|
|
gulong mode;
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STATE (state));
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
object = first_object;
|
|
|
|
|
|
|
|
property_name = first_property_name;
|
|
|
|
mode = first_mode;
|
|
|
|
va_start (args, first_mode);
|
|
|
|
|
|
|
|
g_return_if_fail (G_IS_OBJECT (first_object));
|
|
|
|
g_return_if_fail (first_property_name);
|
|
|
|
|
|
|
|
while (object != NULL)
|
|
|
|
{
|
|
|
|
GParamSpec *pspec;
|
2012-03-17 16:38:06 +00:00
|
|
|
GValue value = G_VALUE_INIT;
|
2010-05-11 14:04:34 +00:00
|
|
|
gchar *error = NULL;
|
2010-08-13 11:12:59 +00:00
|
|
|
gboolean is_delayed = FALSE;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
if (g_str_has_prefix (property_name, "delayed::"))
|
2010-08-13 11:12:59 +00:00
|
|
|
{
|
|
|
|
property_name = strstr (property_name, "::") + 2;
|
|
|
|
is_delayed = TRUE;
|
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-08-13 11:12:59 +00:00
|
|
|
pspec = get_property_from_object (object, property_name);
|
2010-05-20 17:34:34 +00:00
|
|
|
if (pspec == NULL)
|
2010-05-26 12:43:42 +00:00
|
|
|
break;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec),
|
|
|
|
args, 0,
|
|
|
|
&error);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
if (error != NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
g_warning ("%s: %s", G_STRLOC, error);
|
|
|
|
g_free (error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-08-13 11:12:59 +00:00
|
|
|
if (is_delayed)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
gdouble pre_delay = va_arg (args, gdouble);
|
|
|
|
gdouble post_delay = va_arg (args, gdouble);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
clutter_state_set_key (state,
|
|
|
|
source_state_name,
|
|
|
|
target_state_name,
|
|
|
|
object,
|
2010-08-13 11:12:59 +00:00
|
|
|
property_name,
|
2010-05-11 14:04:34 +00:00
|
|
|
mode,
|
|
|
|
&value,
|
|
|
|
pre_delay,
|
|
|
|
post_delay);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
clutter_state_set_key (state,
|
|
|
|
source_state_name,
|
|
|
|
target_state_name,
|
|
|
|
object,
|
|
|
|
property_name,
|
|
|
|
mode,
|
|
|
|
&value,
|
|
|
|
0.0,
|
|
|
|
0.0);
|
|
|
|
}
|
|
|
|
|
2010-08-13 11:12:59 +00:00
|
|
|
g_value_unset (&value);
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
object = va_arg (args, gpointer);
|
2010-05-20 17:34:34 +00:00
|
|
|
if (object != NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
property_name = va_arg (args, gchar*);
|
|
|
|
mode = va_arg (args, gulong);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
va_end (args);
|
|
|
|
}
|
|
|
|
|
2010-05-21 13:13:14 +00:00
|
|
|
static void
|
|
|
|
clutter_state_set_key_internal (ClutterState *state,
|
|
|
|
ClutterStateKey *key)
|
|
|
|
{
|
2010-10-22 15:13:16 +00:00
|
|
|
ClutterStatePrivate *priv = state->priv;
|
2010-05-21 13:13:14 +00:00
|
|
|
State *target_state = key->target_state;
|
|
|
|
GList *old_item = NULL;
|
|
|
|
|
|
|
|
if ((old_item = g_list_find_custom (target_state->keys,
|
|
|
|
key,
|
|
|
|
sort_props_func)))
|
|
|
|
{
|
|
|
|
ClutterStateKey *old_key = old_item->data;
|
|
|
|
|
|
|
|
target_state->keys = g_list_remove (target_state->keys, old_key);
|
|
|
|
clutter_state_key_free (old_key);
|
|
|
|
}
|
|
|
|
|
|
|
|
target_state->keys = g_list_insert_sorted (target_state->keys,
|
|
|
|
key,
|
|
|
|
sort_props_func);
|
2010-10-22 15:13:16 +00:00
|
|
|
|
|
|
|
/* If the current target state is modified, we have some work to do.
|
|
|
|
*
|
|
|
|
* If the animation is running, we add a key to the current animation
|
|
|
|
* with a delay of the current duration so that the new animation will
|
|
|
|
* animate into place.
|
|
|
|
*
|
|
|
|
* If the animation isn't running, but the state is set, we immediately
|
|
|
|
* warp to that state.
|
|
|
|
*/
|
|
|
|
if (key->target_state == priv->target_state)
|
|
|
|
{
|
|
|
|
if (!clutter_timeline_is_playing (priv->timeline))
|
|
|
|
{
|
|
|
|
/* We can warp to the state by setting a NULL state, then setting
|
|
|
|
* the target state again.
|
|
|
|
*/
|
|
|
|
clutter_state_change (state, NULL, FALSE);
|
|
|
|
clutter_state_change (state, target_state->name, FALSE);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Set the ClutterInterval associated with the state */
|
2012-03-17 16:38:06 +00:00
|
|
|
GValue initial = G_VALUE_INIT;
|
2010-10-22 15:13:16 +00:00
|
|
|
gdouble progress = clutter_timeline_get_progress (priv->timeline);
|
|
|
|
|
|
|
|
g_value_init (&initial,
|
|
|
|
clutter_interval_get_value_type (key->interval));
|
2011-07-15 14:06:31 +00:00
|
|
|
|
|
|
|
if (key->is_animatable)
|
|
|
|
{
|
|
|
|
ClutterAnimatable *animatable;
|
|
|
|
|
|
|
|
animatable = CLUTTER_ANIMATABLE (key->object);
|
|
|
|
clutter_animatable_get_initial_state (animatable,
|
|
|
|
key->property_name,
|
|
|
|
&initial);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
g_object_get_property (key->object, key->property_name, &initial);
|
2010-10-22 15:13:16 +00:00
|
|
|
|
|
|
|
if (clutter_alpha_get_mode (key->alpha) != key->mode)
|
|
|
|
clutter_alpha_set_mode (key->alpha, key->mode);
|
|
|
|
|
|
|
|
clutter_interval_set_initial_value (key->interval, &initial);
|
|
|
|
clutter_interval_set_final_value (key->interval, &key->value);
|
|
|
|
|
|
|
|
g_value_unset (&initial);
|
|
|
|
|
|
|
|
/* Set the delay as if the interval had just begun */
|
|
|
|
if (progress > key->pre_delay)
|
|
|
|
key->pre_pre_delay = MIN (progress - key->pre_delay,
|
|
|
|
1.0 - key->post_delay);
|
|
|
|
}
|
|
|
|
}
|
2010-05-21 13:13:14 +00:00
|
|
|
}
|
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
/*
|
2010-07-02 15:44:54 +00:00
|
|
|
* clutter_state_fetch_state:
|
2010-05-26 12:43:42 +00:00
|
|
|
* @state: a #ClutterState
|
|
|
|
* @state_name: the name of the state to be retrieved
|
2010-07-02 15:44:54 +00:00
|
|
|
* @create: %TRUE if the state should be instantiated if not found
|
2010-05-26 12:43:42 +00:00
|
|
|
*
|
|
|
|
* Retrieves the #State structure for @state_name inside the given
|
|
|
|
* #ClutterState instance
|
|
|
|
*
|
2010-07-02 15:44:54 +00:00
|
|
|
* If @state_name is %NULL and @create is %TRUE then NULL will
|
|
|
|
* be returned.
|
2010-05-26 12:43:42 +00:00
|
|
|
*
|
|
|
|
* Return value: a #State structure for the given name, or %NULL
|
|
|
|
*/
|
|
|
|
static State *
|
2010-07-02 15:44:54 +00:00
|
|
|
clutter_state_fetch_state (ClutterState *state,
|
|
|
|
const gchar *state_name,
|
|
|
|
gboolean create)
|
2010-05-26 12:43:42 +00:00
|
|
|
{
|
|
|
|
ClutterStatePrivate *priv = state->priv;
|
|
|
|
State *retval;
|
|
|
|
|
|
|
|
if (state_name == NULL)
|
|
|
|
{
|
2010-06-24 01:26:46 +00:00
|
|
|
return NULL;
|
2010-05-26 12:43:42 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
state_name = g_intern_string (state_name);
|
|
|
|
|
|
|
|
retval = g_hash_table_lookup (priv->states, state_name);
|
2010-07-02 15:44:54 +00:00
|
|
|
if (retval == NULL && create)
|
2010-05-26 12:43:42 +00:00
|
|
|
{
|
|
|
|
retval = state_new (state, state_name);
|
|
|
|
g_hash_table_insert (priv->states, (gpointer) state_name, retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
/**
|
|
|
|
* clutter_state_set_key:
|
2010-05-24 13:20:23 +00:00
|
|
|
* @state: a #ClutterState instance.
|
2011-12-01 10:39:11 +00:00
|
|
|
* @source_state_name: (allow-none): the source transition to specify
|
|
|
|
* transition for, or %NULL to specify the default fallback when a
|
|
|
|
* more specific source state doesn't exist.
|
2010-05-11 14:04:34 +00:00
|
|
|
* @target_state_name: the name of the transition to set a key value for.
|
|
|
|
* @object: the #GObject to set a key for
|
|
|
|
* @property_name: the property to set a key for
|
|
|
|
* @mode: the id of the alpha function to use
|
|
|
|
* @value: the value for property_name of object in state_name
|
2010-05-20 17:57:27 +00:00
|
|
|
* @pre_delay: relative time of the transition to be idle in the beginning
|
|
|
|
* of the transition
|
|
|
|
* @post_delay: relative time of the transition to be idle in the end of
|
|
|
|
* the transition
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
2011-12-01 10:39:11 +00:00
|
|
|
* Sets one specific end key for a state name, @object, @property_name
|
2010-05-11 14:04:34 +00:00
|
|
|
* combination.
|
|
|
|
*
|
2010-09-03 11:14:50 +00:00
|
|
|
* Return value: (transfer none): the #ClutterState instance, allowing
|
|
|
|
* chaining of multiple calls
|
2010-05-20 17:57:27 +00:00
|
|
|
*
|
2010-05-11 14:04:34 +00:00
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
ClutterState *
|
2010-05-24 13:20:23 +00:00
|
|
|
clutter_state_set_key (ClutterState *state,
|
2010-05-11 14:04:34 +00:00
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name,
|
|
|
|
GObject *object,
|
|
|
|
const gchar *property_name,
|
|
|
|
guint mode,
|
|
|
|
const GValue *value,
|
|
|
|
gdouble pre_delay,
|
|
|
|
gdouble post_delay)
|
|
|
|
{
|
2010-05-20 17:34:34 +00:00
|
|
|
GParamSpec *pspec;
|
2010-05-11 14:04:34 +00:00
|
|
|
ClutterStateKey *state_key;
|
2010-05-21 13:13:14 +00:00
|
|
|
State *source_state = NULL;
|
|
|
|
State *target_state;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STATE (state), NULL);
|
2010-05-11 14:04:34 +00:00
|
|
|
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
|
|
|
|
g_return_val_if_fail (property_name, NULL);
|
|
|
|
g_return_val_if_fail (value, NULL);
|
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
pspec = get_property_from_object (object, property_name);
|
|
|
|
if (pspec == NULL)
|
|
|
|
return state;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-07-02 15:44:54 +00:00
|
|
|
source_state = clutter_state_fetch_state (state, source_state_name, TRUE);
|
|
|
|
target_state = clutter_state_fetch_state (state, target_state_name, TRUE);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
property_name = g_intern_string (property_name);
|
2010-05-20 17:34:34 +00:00
|
|
|
state_key = clutter_state_key_new (target_state,
|
|
|
|
object, property_name, pspec,
|
|
|
|
mode);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
state_key->source_state = source_state;
|
2010-05-11 14:04:34 +00:00
|
|
|
state_key->pre_delay = pre_delay;
|
|
|
|
state_key->post_delay = post_delay;
|
|
|
|
|
|
|
|
g_value_init (&state_key->value, G_VALUE_TYPE (value));
|
|
|
|
g_value_copy (value, &state_key->value);
|
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
clutter_state_set_key_internal (state, state_key);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-24 13:20:23 +00:00
|
|
|
return state;
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_get_states:
|
|
|
|
* @state: a #ClutterState instance.
|
|
|
|
*
|
2010-05-20 17:57:27 +00:00
|
|
|
* Gets a list of all the state names managed by this #ClutterState.
|
|
|
|
*
|
|
|
|
* Return value: (transfer container) (element-type utf8): a newly allocated
|
|
|
|
* #GList of state names. The contents of the returned #GList are owned
|
|
|
|
* by the #ClutterState and should not be modified or freed. Use
|
|
|
|
* g_list_free() to free the resources allocated by the returned list when
|
|
|
|
* done using it
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
GList *
|
|
|
|
clutter_state_get_states (ClutterState *state)
|
|
|
|
{
|
2010-05-20 17:57:27 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_STATE (state), NULL);
|
2010-05-11 14:04:34 +00:00
|
|
|
return g_hash_table_get_keys (state->priv->states);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_get_keys:
|
|
|
|
* @state: a #ClutterState instance.
|
2010-05-20 17:57:27 +00:00
|
|
|
* @source_state_name: (allow-none): the source transition name to query,
|
|
|
|
* or %NULL for all source states
|
|
|
|
* @target_state_name: (allow-none): the target transition name to query,
|
|
|
|
* or %NULL for all target states
|
|
|
|
* @object: (allow-none): the specific object instance to list keys for,
|
|
|
|
* or %NULL for all managed objects
|
|
|
|
* @property_name: (allow-none): the property name to search for, or %NULL
|
|
|
|
* for all properties.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Returns a list of pointers to opaque structures with accessor functions
|
|
|
|
* that describe the keys added to an animator.
|
|
|
|
*
|
2010-09-08 15:41:47 +00:00
|
|
|
* Return value: (transfer container) (element-type Clutter.StateKey): a
|
2010-05-20 17:57:27 +00:00
|
|
|
* newly allocated #GList of #ClutterStateKey<!-- -->s. The contents of
|
|
|
|
* the returned list are owned by the #ClutterState and should not be
|
|
|
|
* modified or freed. Use g_list_free() to free the resources allocated
|
|
|
|
* by the returned list when done using it
|
|
|
|
*
|
2010-05-11 14:04:34 +00:00
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
GList *
|
|
|
|
clutter_state_get_keys (ClutterState *state,
|
2010-05-20 17:57:27 +00:00
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name,
|
|
|
|
GObject *object,
|
|
|
|
const gchar *property_name)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
GList *s, *state_list;
|
|
|
|
GList *targets = NULL;
|
|
|
|
State *source_state = NULL;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STATE (state), NULL);
|
|
|
|
|
|
|
|
source_state_name = g_intern_string (source_state_name);
|
|
|
|
target_state_name = g_intern_string (target_state_name);
|
|
|
|
property_name = g_intern_string (property_name);
|
|
|
|
|
|
|
|
if (target_state_name != NULL)
|
2010-05-20 17:57:27 +00:00
|
|
|
state_list = g_list_append (NULL, (gpointer) target_state_name);
|
2010-05-11 14:04:34 +00:00
|
|
|
else
|
2010-05-20 17:57:27 +00:00
|
|
|
state_list = clutter_state_get_states (state);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
if (source_state_name)
|
2010-07-02 15:44:54 +00:00
|
|
|
source_state = clutter_state_fetch_state (state, source_state_name, FALSE);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
for (s = state_list; s != NULL; s = s->next)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
State *target_state;
|
|
|
|
|
2010-07-02 15:44:54 +00:00
|
|
|
target_state = clutter_state_fetch_state (state, s->data, FALSE);
|
2010-05-26 12:43:42 +00:00
|
|
|
if (target_state != NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
GList *k;
|
|
|
|
|
|
|
|
for (k = target_state->keys; k; k = k->next)
|
|
|
|
{
|
|
|
|
ClutterStateKey *key = k->data;
|
2010-05-20 17:57:27 +00:00
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
if ((object == NULL || (object == key->object)) &&
|
|
|
|
(source_state_name == NULL ||
|
|
|
|
source_state == key->source_state) &&
|
|
|
|
(property_name == NULL ||
|
|
|
|
(property_name == key->property_name)))
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 17:57:27 +00:00
|
|
|
targets = g_list_prepend (targets, key);
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-05-20 17:57:27 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
g_list_free (state_list);
|
2010-05-20 17:57:27 +00:00
|
|
|
|
|
|
|
return g_list_reverse (targets);
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_remove_key:
|
|
|
|
* @state: a #ClutterState instance.
|
2010-05-20 17:57:27 +00:00
|
|
|
* @source_state_name: (allow-none): the source state name to query,
|
|
|
|
* or %NULL for all source states
|
|
|
|
* @target_state_name: (allow-none): the target state name to query,
|
|
|
|
* or %NULL for all target states
|
|
|
|
* @object: (allow-none): the specific object instance to list keys for,
|
|
|
|
* or %NULL for all managed objects
|
|
|
|
* @property_name: (allow-none): the property name to search for,
|
|
|
|
* or %NULL for all properties.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Removes all keys matching the search criteria passed in arguments.
|
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_state_remove_key (ClutterState *state,
|
2010-05-20 17:57:27 +00:00
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name,
|
|
|
|
GObject *object,
|
|
|
|
const gchar *property_name)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 17:34:34 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_STATE (state));
|
|
|
|
|
|
|
|
clutter_state_remove_key_internal (state,
|
|
|
|
source_state_name, target_state_name,
|
|
|
|
object, property_name,
|
|
|
|
FALSE);
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_get_timeline:
|
|
|
|
* @state: a #ClutterState
|
|
|
|
*
|
2010-05-20 17:57:27 +00:00
|
|
|
* Gets the timeline driving the #ClutterState
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
2010-05-20 17:57:27 +00:00
|
|
|
* Return value: (transfer none): the #ClutterTimeline that drives
|
|
|
|
* the state change animations. The returned timeline is owned
|
|
|
|
* by the #ClutterState and it should not be unreferenced directly
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
ClutterTimeline *
|
|
|
|
clutter_state_get_timeline (ClutterState *state)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STATE (state), NULL);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return state->priv->timeline;
|
|
|
|
}
|
|
|
|
|
2010-05-21 09:37:42 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_state_set_property (GObject *object,
|
|
|
|
guint prop_id,
|
|
|
|
const GValue *value,
|
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
|
|
|
ClutterState *state = CLUTTER_STATE (object);
|
|
|
|
|
|
|
|
switch (prop_id)
|
|
|
|
{
|
2010-07-02 15:44:54 +00:00
|
|
|
case PROP_STATE:
|
2010-07-07 17:14:43 +00:00
|
|
|
clutter_state_set_state (state, g_value_get_string (value));
|
2010-05-21 09:37:42 +00:00
|
|
|
break;
|
2010-06-16 16:33:48 +00:00
|
|
|
case PROP_DURATION:
|
|
|
|
state->priv->duration = g_value_get_uint (value);
|
|
|
|
break;
|
2010-05-21 09:37:42 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_state_get_property (GObject *object,
|
|
|
|
guint prop_id,
|
|
|
|
GValue *value,
|
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
|
|
|
ClutterState *state = CLUTTER_STATE (object);
|
|
|
|
switch (prop_id)
|
|
|
|
{
|
2010-07-02 15:44:54 +00:00
|
|
|
case PROP_STATE:
|
2010-05-21 09:37:42 +00:00
|
|
|
g_value_set_string (value,
|
2010-07-02 15:44:54 +00:00
|
|
|
clutter_state_get_state (state));
|
2010-05-21 09:37:42 +00:00
|
|
|
break;
|
2010-06-16 16:33:48 +00:00
|
|
|
case PROP_DURATION:
|
|
|
|
g_value_set_uint (value, state->priv->duration);
|
|
|
|
break;
|
2010-05-21 09:37:42 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
static void
|
|
|
|
clutter_state_class_init (ClutterStateClass *klass)
|
|
|
|
{
|
|
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
2010-05-21 09:37:42 +00:00
|
|
|
GParamSpec *pspec;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
g_type_class_add_private (klass, sizeof (ClutterStatePrivate));
|
2010-05-12 16:03:25 +00:00
|
|
|
|
2010-05-21 09:37:42 +00:00
|
|
|
gobject_class->finalize = clutter_state_finalize;
|
|
|
|
gobject_class->set_property = clutter_state_set_property;
|
|
|
|
gobject_class->get_property = clutter_state_get_property;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ClutterState::completed:
|
|
|
|
* @state: the #ClutterState that emitted the signal
|
|
|
|
*
|
|
|
|
* The ::completed signal is emitted when a #ClutterState reaches
|
2010-10-22 16:41:06 +00:00
|
|
|
* the target state specified by clutter_state_set_state() or
|
|
|
|
* clutter_state_warp_to_state().
|
2010-05-20 17:34:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-20 17:34:34 +00:00
|
|
|
*/
|
2010-05-12 16:03:25 +00:00
|
|
|
state_signals[COMPLETED] =
|
2010-05-20 17:34:34 +00:00
|
|
|
g_signal_new (I_("completed"),
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterStateClass, completed),
|
|
|
|
NULL, NULL,
|
2010-06-11 14:49:46 +00:00
|
|
|
_clutter_marshal_VOID__VOID,
|
2010-05-20 17:34:34 +00:00
|
|
|
G_TYPE_NONE, 0);
|
2010-05-21 09:37:42 +00:00
|
|
|
|
|
|
|
/**
|
2010-07-02 15:44:54 +00:00
|
|
|
* ClutterState:state:
|
2010-05-21 09:37:42 +00:00
|
|
|
*
|
|
|
|
* The currently set target state, setting it causes the
|
|
|
|
* state machine to transition to the new state, use
|
2010-10-22 16:41:06 +00:00
|
|
|
* clutter_state_warp_to_state() to change state without
|
|
|
|
* a transition.
|
2012-04-11 17:30:40 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-21 09:37:42 +00:00
|
|
|
*/
|
2010-07-02 15:44:54 +00:00
|
|
|
pspec = g_param_spec_string ("state",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("State"),
|
|
|
|
P_("Currently set state, (transition to this state might not be complete)"),
|
2010-06-24 01:26:46 +00:00
|
|
|
NULL,
|
2010-05-21 09:37:42 +00:00
|
|
|
CLUTTER_PARAM_READWRITE);
|
2010-06-21 09:20:32 +00:00
|
|
|
obj_props[PROP_STATE] = pspec;
|
2010-07-02 15:44:54 +00:00
|
|
|
g_object_class_install_property (gobject_class, PROP_STATE, pspec);
|
2010-06-16 16:33:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ClutterState:duration:
|
|
|
|
*
|
|
|
|
* Default duration used if an duration has not been specified for a specific
|
|
|
|
* source/target state pair. The values is in milliseconds.
|
2012-04-11 17:30:40 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-06-16 16:33:48 +00:00
|
|
|
*/
|
|
|
|
pspec = g_param_spec_uint ("duration",
|
2010-06-03 11:57:50 +00:00
|
|
|
P_("Duration"),
|
|
|
|
P_("Default transition duration"),
|
2010-06-16 16:33:48 +00:00
|
|
|
0, 86400000, 1000,
|
|
|
|
CLUTTER_PARAM_READWRITE);
|
2010-06-21 09:20:32 +00:00
|
|
|
obj_props[PROP_DURATION] = pspec;
|
2010-06-16 16:33:48 +00:00
|
|
|
g_object_class_install_property (gobject_class, PROP_DURATION, pspec);
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_state_init (ClutterState *self)
|
|
|
|
{
|
|
|
|
ClutterStatePrivate *priv;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
priv = self->priv = CLUTTER_STATE_GET_PRIVATE (self);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
priv->states = g_hash_table_new_full (g_direct_hash, g_direct_equal,
|
2010-05-20 17:34:34 +00:00
|
|
|
NULL,
|
|
|
|
state_free);
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
self->priv->source_state_name = NULL;
|
|
|
|
self->priv->target_state_name = NULL;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
self->priv->duration = 1000;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
priv->timeline = clutter_timeline_new (1000);
|
|
|
|
g_signal_connect (priv->timeline, "new-frame",
|
2010-05-20 17:34:34 +00:00
|
|
|
G_CALLBACK (clutter_state_new_frame),
|
|
|
|
self);
|
2010-05-11 14:04:34 +00:00
|
|
|
g_signal_connect (priv->timeline, "completed",
|
2010-05-20 17:34:34 +00:00
|
|
|
G_CALLBACK (clutter_state_completed),
|
|
|
|
self);
|
|
|
|
|
|
|
|
priv->slave_timeline = clutter_timeline_new (SLAVE_TIMELINE_LENGTH);
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_get_animator:
|
|
|
|
* @state: a #ClutterState instance.
|
|
|
|
* @source_state_name: the name of a source state
|
|
|
|
* @target_state_name: the name of a target state
|
|
|
|
*
|
2010-05-20 17:57:27 +00:00
|
|
|
* Retrieves the #ClutterAnimator that is being used for transitioning
|
|
|
|
* between the two states, if any has been set
|
|
|
|
*
|
|
|
|
* Return value: (transfer none): a #ClutterAnimator instance, or %NULL
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
2010-05-20 17:57:27 +00:00
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
ClutterAnimator *
|
|
|
|
clutter_state_get_animator (ClutterState *state,
|
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name)
|
|
|
|
{
|
2012-01-16 23:49:49 +00:00
|
|
|
State *target_state;
|
|
|
|
guint i;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STATE (state), NULL);
|
|
|
|
|
|
|
|
source_state_name = g_intern_string (source_state_name);
|
2010-06-24 01:26:46 +00:00
|
|
|
if (source_state_name == g_intern_static_string (""))
|
2010-05-11 14:04:34 +00:00
|
|
|
source_state_name = NULL;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
target_state_name = g_intern_string (target_state_name);
|
|
|
|
|
2010-07-02 15:44:54 +00:00
|
|
|
target_state = clutter_state_fetch_state (state, target_state_name, FALSE);
|
2010-05-20 17:34:34 +00:00
|
|
|
if (target_state == NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
return NULL;
|
|
|
|
|
2012-01-16 23:49:49 +00:00
|
|
|
for (i = 0; i < target_state->animators->len; i++)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2012-01-16 23:49:49 +00:00
|
|
|
const StateAnimator *animator;
|
|
|
|
|
|
|
|
animator = &g_array_index (target_state->animators, StateAnimator, i);
|
|
|
|
if (animator->source_state_name == source_state_name)
|
|
|
|
return animator->animator;
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_set_animator:
|
|
|
|
* @state: a #ClutterState instance.
|
|
|
|
* @source_state_name: the name of a source state
|
|
|
|
* @target_state_name: the name of a target state
|
2010-05-20 17:57:27 +00:00
|
|
|
* @animator: (allow-none): a #ClutterAnimator instance, or %NULL to
|
|
|
|
* unset an existing #ClutterAnimator
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
2010-05-20 17:57:27 +00:00
|
|
|
* Specifies a #ClutterAnimator to be used when transitioning between
|
|
|
|
* the two named states.
|
|
|
|
*
|
|
|
|
* The @animator allows specifying a transition between the state that is
|
2010-09-20 13:31:53 +00:00
|
|
|
* more elaborate than the basic transitions allowed by the tweening of
|
|
|
|
* properties defined in the #ClutterState keys.
|
2010-05-20 17:57:27 +00:00
|
|
|
*
|
|
|
|
* If @animator is %NULL it will unset an existing animator.
|
|
|
|
*
|
|
|
|
* #ClutterState will take a reference on the passed @animator, if any
|
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_state_set_animator (ClutterState *state,
|
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name,
|
|
|
|
ClutterAnimator *animator)
|
|
|
|
{
|
2010-05-20 17:34:34 +00:00
|
|
|
State *target_state;
|
2012-01-16 23:49:49 +00:00
|
|
|
guint i;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STATE (state));
|
|
|
|
|
|
|
|
source_state_name = g_intern_string (source_state_name);
|
|
|
|
target_state_name = g_intern_string (target_state_name);
|
|
|
|
|
2010-09-15 12:46:19 +00:00
|
|
|
target_state = clutter_state_fetch_state (state, target_state_name, TRUE);
|
2010-05-20 17:34:34 +00:00
|
|
|
if (target_state == NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
return;
|
|
|
|
|
2012-01-16 23:49:49 +00:00
|
|
|
for (i = 0; target_state->animators->len; i++)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2012-01-16 23:49:49 +00:00
|
|
|
StateAnimator *a;
|
|
|
|
|
|
|
|
a = &g_array_index (target_state->animators, StateAnimator, i);
|
|
|
|
if (a->source_state_name == source_state_name)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2012-01-16 23:49:49 +00:00
|
|
|
g_object_unref (a->animator);
|
2010-05-20 17:34:34 +00:00
|
|
|
|
|
|
|
if (animator != NULL)
|
2012-01-16 23:49:49 +00:00
|
|
|
a->animator = g_object_ref (animator);
|
2010-05-20 17:34:34 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* remove the matched animator if passed NULL */
|
|
|
|
g_array_remove_index (target_state->animators, i);
|
|
|
|
}
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-20 17:34:34 +00:00
|
|
|
if (animator != NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-09-20 13:31:53 +00:00
|
|
|
StateAnimator state_animator = {
|
|
|
|
source_state_name,
|
|
|
|
g_object_ref (animator)
|
|
|
|
};
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
g_array_append_val (target_state->animators, state_animator);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static gpointer
|
|
|
|
clutter_state_key_copy (gpointer boxed)
|
|
|
|
{
|
2010-05-20 17:57:27 +00:00
|
|
|
if (boxed != NULL)
|
|
|
|
{
|
|
|
|
ClutterStateKey *key = boxed;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-20 17:57:27 +00:00
|
|
|
key->ref_count += 1;
|
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-20 17:57:27 +00:00
|
|
|
return boxed;
|
2010-05-11 14:04:34 +00:00
|
|
|
}
|
|
|
|
|
2010-10-08 14:21:57 +00:00
|
|
|
G_DEFINE_BOXED_TYPE (ClutterStateKey, clutter_state_key,
|
|
|
|
clutter_state_key_copy,
|
|
|
|
clutter_state_key_free);
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_key_get_pre_delay:
|
|
|
|
* @state_key: a #ClutterStateKey
|
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Retrieves the pause before transitioning starts as a fraction of
|
|
|
|
* the total transition time.
|
|
|
|
*
|
|
|
|
* Return value: the pre delay used before starting the transition.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
gdouble
|
2010-05-20 16:34:36 +00:00
|
|
|
clutter_state_key_get_pre_delay (const ClutterStateKey *state_key)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 16:34:36 +00:00
|
|
|
g_return_val_if_fail (state_key != NULL, 0.0);
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return state_key->pre_delay;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_key_get_post_delay:
|
|
|
|
* @state_key: a #ClutterStateKey
|
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Retrieves the duration of the pause after transitioning is complete
|
|
|
|
* as a fraction of the total transition time.
|
|
|
|
*
|
|
|
|
* Return value: the post delay, used after doing the transition.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
gdouble
|
2010-05-20 16:34:36 +00:00
|
|
|
clutter_state_key_get_post_delay (const ClutterStateKey *state_key)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 16:34:36 +00:00
|
|
|
g_return_val_if_fail (state_key != NULL, 0.0);
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return state_key->post_delay;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_key_get_mode:
|
|
|
|
* @state_key: a #ClutterStateKey
|
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Retrieves the easing mode used for @state_key.
|
|
|
|
*
|
|
|
|
* Return value: the mode of a #ClutterStateKey
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
gulong
|
2010-05-20 16:34:36 +00:00
|
|
|
clutter_state_key_get_mode (const ClutterStateKey *state_key)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 16:34:36 +00:00
|
|
|
g_return_val_if_fail (state_key != NULL, 0);
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return state_key->mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_key_get_value:
|
|
|
|
* @state_key: a #ClutterStateKey
|
2010-05-20 16:34:36 +00:00
|
|
|
* @value: a #GValue initialized with the correct type for the @state_key
|
|
|
|
*
|
2010-08-08 18:17:14 +00:00
|
|
|
* Retrieves a copy of the value for a #ClutterStateKey.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* The #GValue needs to be already initialized for the value type
|
2010-08-08 18:17:14 +00:00
|
|
|
* of the property or to a type that allow transformation from the value
|
|
|
|
* type of the key.
|
|
|
|
*
|
|
|
|
* Use g_value_unset() when done.
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the value was successfully retrieved,
|
|
|
|
* and %FALSE otherwise
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
2010-08-08 18:17:14 +00:00
|
|
|
gboolean
|
2010-05-20 16:34:36 +00:00
|
|
|
clutter_state_key_get_value (const ClutterStateKey *state_key,
|
|
|
|
GValue *value)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-08-08 18:17:14 +00:00
|
|
|
g_return_val_if_fail (state_key != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (value != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (G_VALUE_TYPE (value) != G_TYPE_INVALID, FALSE);
|
2010-05-20 16:34:36 +00:00
|
|
|
|
|
|
|
if (!g_type_is_a (G_VALUE_TYPE (&state_key->value), G_VALUE_TYPE (value)))
|
|
|
|
{
|
|
|
|
if (g_value_type_compatible (G_VALUE_TYPE (&state_key->value),
|
|
|
|
G_VALUE_TYPE (value)))
|
|
|
|
{
|
|
|
|
g_value_copy (&state_key->value, value);
|
2010-08-08 18:17:14 +00:00
|
|
|
return TRUE;
|
2010-05-20 16:34:36 +00:00
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
|
2010-05-20 16:34:36 +00:00
|
|
|
if (g_value_type_transformable (G_VALUE_TYPE (&state_key->value),
|
|
|
|
G_VALUE_TYPE (value)))
|
|
|
|
{
|
|
|
|
if (g_value_transform (&state_key->value, value))
|
2010-08-08 18:17:14 +00:00
|
|
|
return TRUE;
|
2010-05-20 16:34:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
g_warning ("%s: Unable to convert from %s to %s for the "
|
|
|
|
"property '%s' of object %s in the state key",
|
|
|
|
G_STRLOC,
|
|
|
|
g_type_name (G_VALUE_TYPE (&state_key->value)),
|
|
|
|
g_type_name (G_VALUE_TYPE (value)),
|
|
|
|
state_key->property_name,
|
|
|
|
G_OBJECT_TYPE_NAME (state_key->object));
|
2010-08-08 18:17:14 +00:00
|
|
|
|
|
|
|
return FALSE;
|
2010-05-20 16:34:36 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
g_value_copy (&state_key->value, value);
|
2010-08-08 18:17:14 +00:00
|
|
|
|
|
|
|
return TRUE;
|
2010-05-20 16:34:36 +00:00
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_key_get_object:
|
|
|
|
* @state_key: a #ClutterStateKey
|
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Retrieves the object instance this #ClutterStateKey applies to.
|
|
|
|
*
|
|
|
|
* Return value: (transfer none): the object this state key applies to.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
GObject *
|
2010-05-20 16:34:36 +00:00
|
|
|
clutter_state_key_get_object (const ClutterStateKey *state_key)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (state_key, NULL);
|
2010-05-20 16:34:36 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return state_key->object;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_key_get_property_name:
|
|
|
|
* @state_key: a #ClutterStateKey
|
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Retrieves the name of the property this #ClutterStateKey applies to
|
|
|
|
*
|
|
|
|
* Return value: the name of the property. The returned string is owned
|
|
|
|
* by the #ClutterStateKey and should never be modified or freed
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
Eliminate G_CONST_RETURN
The G_CONST_RETURN define in GLib is, and has always been, a bit fuzzy.
We always used it to conform to the platform, at least for public-facing
API.
At first I assumed it has something to do with brain-damaged compilers
or with weird platforms where const was not really supported; sadly,
it's something much, much worse: it's a define that can be toggled at
compile-time to remove const from the signature of public API. This is a
truly terrifying feature that I assume was added in the past century,
and whose inception clearly had something to do with massive doses of
absynthe and opium — because any other explanation would make the
existence of such a feature even worse than assuming drugs had anything
to do with it.
Anyway, and pleasing the gods, this dubious feature is being
removed/deprecated in GLib; see bug:
https://bugzilla.gnome.org/show_bug.cgi?id=644611
Before deprecation, though, we should just remove its usage from the
whole API. We should especially remove its usage from Cally's internals,
since there it never made sense in the first place.
2011-06-07 14:49:20 +00:00
|
|
|
const gchar *
|
2010-05-20 16:34:36 +00:00
|
|
|
clutter_state_key_get_property_name (const ClutterStateKey *state_key)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (state_key, NULL);
|
2010-05-20 16:34:36 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return state_key->property_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_key_get_source_state_name:
|
|
|
|
* @state_key: a #ClutterStateKey
|
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Retrieves the name of the source state of the @state_key
|
|
|
|
*
|
|
|
|
* Return value: the name of the source state for this key, or %NULL
|
|
|
|
* if this is the generic state key for the given property when
|
|
|
|
* transitioning to the target state. The returned string is owned
|
|
|
|
* by the #ClutterStateKey and should never be modified or freed
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
Eliminate G_CONST_RETURN
The G_CONST_RETURN define in GLib is, and has always been, a bit fuzzy.
We always used it to conform to the platform, at least for public-facing
API.
At first I assumed it has something to do with brain-damaged compilers
or with weird platforms where const was not really supported; sadly,
it's something much, much worse: it's a define that can be toggled at
compile-time to remove const from the signature of public API. This is a
truly terrifying feature that I assume was added in the past century,
and whose inception clearly had something to do with massive doses of
absynthe and opium — because any other explanation would make the
existence of such a feature even worse than assuming drugs had anything
to do with it.
Anyway, and pleasing the gods, this dubious feature is being
removed/deprecated in GLib; see bug:
https://bugzilla.gnome.org/show_bug.cgi?id=644611
Before deprecation, though, we should just remove its usage from the
whole API. We should especially remove its usage from Cally's internals,
since there it never made sense in the first place.
2011-06-07 14:49:20 +00:00
|
|
|
const gchar *
|
2010-05-20 16:34:36 +00:00
|
|
|
clutter_state_key_get_source_state_name (const ClutterStateKey *state_key)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (state_key, NULL);
|
2010-05-20 16:34:36 +00:00
|
|
|
|
|
|
|
if (state_key->source_state != NULL)
|
|
|
|
return state_key->source_state->name;
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_state_key_get_target_state_name:
|
|
|
|
* @state_key: a #ClutterStateKey
|
|
|
|
*
|
|
|
|
* Get the name of the source state this #ClutterStateKey contains,
|
|
|
|
* or NULL if this is the generic state key for the given property
|
|
|
|
* when transitioning to the target state.
|
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Return value: the name of the source state for this key, or NULL if
|
|
|
|
* the key is generic
|
|
|
|
*
|
2010-05-11 14:04:34 +00:00
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
Eliminate G_CONST_RETURN
The G_CONST_RETURN define in GLib is, and has always been, a bit fuzzy.
We always used it to conform to the platform, at least for public-facing
API.
At first I assumed it has something to do with brain-damaged compilers
or with weird platforms where const was not really supported; sadly,
it's something much, much worse: it's a define that can be toggled at
compile-time to remove const from the signature of public API. This is a
truly terrifying feature that I assume was added in the past century,
and whose inception clearly had something to do with massive doses of
absynthe and opium — because any other explanation would make the
existence of such a feature even worse than assuming drugs had anything
to do with it.
Anyway, and pleasing the gods, this dubious feature is being
removed/deprecated in GLib; see bug:
https://bugzilla.gnome.org/show_bug.cgi?id=644611
Before deprecation, though, we should just remove its usage from the
whole API. We should especially remove its usage from Cally's internals,
since there it never made sense in the first place.
2011-06-07 14:49:20 +00:00
|
|
|
const gchar *
|
2010-05-20 16:34:36 +00:00
|
|
|
clutter_state_key_get_target_state_name (const ClutterStateKey *state_key)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (state_key, NULL);
|
2010-05-20 16:34:36 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return state_key->target_state->name;
|
|
|
|
}
|
|
|
|
|
2010-07-06 12:47:49 +00:00
|
|
|
/**
|
|
|
|
* clutter_state_key_get_property_type:
|
|
|
|
* @key: a #ClutterStateKey
|
|
|
|
*
|
|
|
|
* Retrieves the #GType of the property a key applies to
|
|
|
|
*
|
|
|
|
* You can use this type to initialize the #GValue to pass to
|
|
|
|
* clutter_state_key_get_value()
|
|
|
|
*
|
|
|
|
* Return value: the #GType of the property
|
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-07-06 12:47:49 +00:00
|
|
|
*/
|
|
|
|
GType
|
|
|
|
clutter_state_key_get_property_type (const ClutterStateKey *key)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (key != NULL, G_TYPE_INVALID);
|
|
|
|
|
|
|
|
return G_VALUE_TYPE (&key->value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
/**
|
|
|
|
* clutter_state_set_duration:
|
|
|
|
* @state: a #ClutterState
|
2010-05-26 12:43:42 +00:00
|
|
|
* @source_state_name: (allow-none): the name of the source state, or %NULL
|
|
|
|
* @target_state_name: (allow-none): the name of the target state, or %NULL
|
|
|
|
* @duration: the duration of the transition, in milliseconds
|
|
|
|
*
|
|
|
|
* Sets the duration of a transition.
|
|
|
|
*
|
|
|
|
* If both state names are %NULL the default duration for @state is set.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
2010-05-26 12:43:42 +00:00
|
|
|
* If only @target_state_name is specified, the passed @duration becomes
|
|
|
|
* the default duration for transitions to the target state.
|
|
|
|
*
|
|
|
|
* If both states names are specified, the passed @duration only applies
|
|
|
|
* to the specified transition.
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_state_set_duration (ClutterState *state,
|
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name,
|
|
|
|
guint duration)
|
|
|
|
{
|
|
|
|
State *target_state;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_STATE (state));
|
|
|
|
|
|
|
|
source_state_name = g_intern_string (source_state_name);
|
2010-06-24 01:26:46 +00:00
|
|
|
if (source_state_name == g_intern_static_string (""))
|
2010-05-11 14:04:34 +00:00
|
|
|
source_state_name = NULL;
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
target_state_name = g_intern_string (target_state_name);
|
2010-06-24 01:26:46 +00:00
|
|
|
if (target_state_name == g_intern_static_string (""))
|
2010-05-11 14:04:34 +00:00
|
|
|
target_state_name = NULL;
|
|
|
|
|
|
|
|
if (target_state_name == NULL)
|
|
|
|
{
|
|
|
|
state->priv->duration = duration;
|
|
|
|
return;
|
|
|
|
}
|
2010-05-20 17:34:34 +00:00
|
|
|
|
2010-07-02 15:44:54 +00:00
|
|
|
target_state = clutter_state_fetch_state (state, target_state_name, FALSE);
|
2010-05-20 17:34:34 +00:00
|
|
|
if (target_state != NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
2010-05-20 17:34:34 +00:00
|
|
|
if (source_state_name != NULL)
|
|
|
|
g_hash_table_insert (target_state->durations,
|
|
|
|
(gpointer) source_state_name,
|
2010-05-11 14:04:34 +00:00
|
|
|
GINT_TO_POINTER (duration));
|
|
|
|
else
|
2010-05-20 17:34:34 +00:00
|
|
|
g_hash_table_insert (target_state->durations,
|
|
|
|
NULL,
|
2010-05-11 14:04:34 +00:00
|
|
|
GINT_TO_POINTER (duration));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-12 16:03:25 +00:00
|
|
|
/**
|
|
|
|
* clutter_state_get_duration:
|
|
|
|
* @state: a #ClutterState
|
2010-05-20 16:34:36 +00:00
|
|
|
* @source_state_name: (allow-none): the name of the source state to
|
|
|
|
* get the duration of, or %NULL
|
|
|
|
* @target_state_name: (allow-none): the name of the source state to
|
|
|
|
* get the duration of, or %NULL
|
2010-05-11 14:04:34 +00:00
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Queries the duration used for transitions between a source and
|
|
|
|
* target state pair
|
2010-05-12 16:03:25 +00:00
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* The semantics for the query are the same as the semantics used for
|
|
|
|
* setting the duration with clutter_state_set_duration()
|
2010-05-12 16:03:25 +00:00
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Return value: the duration, in milliseconds
|
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-11 14:04:34 +00:00
|
|
|
*/
|
|
|
|
guint
|
|
|
|
clutter_state_get_duration (ClutterState *state,
|
|
|
|
const gchar *source_state_name,
|
|
|
|
const gchar *target_state_name)
|
|
|
|
{
|
|
|
|
State *target_state;
|
2010-05-20 16:34:36 +00:00
|
|
|
guint ret = 0;
|
2010-05-11 14:04:34 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STATE (state), 0);
|
|
|
|
|
|
|
|
source_state_name = g_intern_string (source_state_name);
|
2010-06-24 01:26:46 +00:00
|
|
|
if (source_state_name == g_intern_static_string (""))
|
2010-05-11 14:04:34 +00:00
|
|
|
source_state_name = NULL;
|
2010-05-20 16:34:36 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
target_state_name = g_intern_string (target_state_name);
|
2010-06-24 01:26:46 +00:00
|
|
|
if (target_state_name == g_intern_static_string (""))
|
2010-05-11 14:04:34 +00:00
|
|
|
target_state_name = NULL;
|
|
|
|
|
|
|
|
if (target_state_name == NULL)
|
2010-05-20 16:34:36 +00:00
|
|
|
return state->priv->duration;
|
|
|
|
|
2010-07-02 15:44:54 +00:00
|
|
|
target_state = clutter_state_fetch_state (state, target_state_name, FALSE);
|
2010-05-20 16:34:36 +00:00
|
|
|
if (target_state != NULL)
|
2010-05-11 14:04:34 +00:00
|
|
|
{
|
|
|
|
if (source_state_name)
|
2011-09-19 16:30:00 +00:00
|
|
|
{
|
|
|
|
ret = GPOINTER_TO_INT (g_hash_table_lookup (target_state->durations,
|
|
|
|
source_state_name));
|
|
|
|
if(!ret)
|
|
|
|
ret = GPOINTER_TO_INT (g_hash_table_lookup (target_state->durations,
|
|
|
|
NULL));
|
|
|
|
}
|
2010-05-11 14:04:34 +00:00
|
|
|
else
|
|
|
|
ret = GPOINTER_TO_INT (g_hash_table_lookup (target_state->durations,
|
|
|
|
NULL));
|
|
|
|
}
|
2010-05-20 16:34:36 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
if (!ret)
|
|
|
|
ret = state->priv->duration;
|
2010-05-20 16:34:36 +00:00
|
|
|
|
2010-05-11 14:04:34 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2010-05-12 16:03:25 +00:00
|
|
|
|
|
|
|
/**
|
2010-07-02 15:44:54 +00:00
|
|
|
* clutter_state_get_state:
|
2010-05-12 16:03:25 +00:00
|
|
|
* @state: a #ClutterState
|
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Queries the currently set target state.
|
2010-05-12 16:03:25 +00:00
|
|
|
*
|
2010-07-02 15:44:54 +00:00
|
|
|
* During a transition this function will return the target of the transition.
|
2010-05-20 16:34:36 +00:00
|
|
|
*
|
|
|
|
* This function is useful when called from handlers of the
|
|
|
|
* #ClutterState::completed signal.
|
2010-05-12 16:03:25 +00:00
|
|
|
*
|
2010-05-20 16:34:36 +00:00
|
|
|
* Return value: a string containing the target state. The returned string
|
|
|
|
* is owned by the #ClutterState and should not be modified or freed
|
|
|
|
*
|
|
|
|
* Since: 1.4
|
2012-04-11 17:30:40 +00:00
|
|
|
* Deprecated: 1.12: Use #ClutterKeyframeTransition and
|
|
|
|
* #ClutterTransitionGroup instead
|
2010-05-12 16:03:25 +00:00
|
|
|
*/
|
Eliminate G_CONST_RETURN
The G_CONST_RETURN define in GLib is, and has always been, a bit fuzzy.
We always used it to conform to the platform, at least for public-facing
API.
At first I assumed it has something to do with brain-damaged compilers
or with weird platforms where const was not really supported; sadly,
it's something much, much worse: it's a define that can be toggled at
compile-time to remove const from the signature of public API. This is a
truly terrifying feature that I assume was added in the past century,
and whose inception clearly had something to do with massive doses of
absynthe and opium — because any other explanation would make the
existence of such a feature even worse than assuming drugs had anything
to do with it.
Anyway, and pleasing the gods, this dubious feature is being
removed/deprecated in GLib; see bug:
https://bugzilla.gnome.org/show_bug.cgi?id=644611
Before deprecation, though, we should just remove its usage from the
whole API. We should especially remove its usage from Cally's internals,
since there it never made sense in the first place.
2011-06-07 14:49:20 +00:00
|
|
|
const gchar *
|
2010-07-02 15:44:54 +00:00
|
|
|
clutter_state_get_state (ClutterState *state)
|
2010-05-12 16:03:25 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_STATE (state), NULL);
|
2010-05-20 16:34:36 +00:00
|
|
|
|
2010-05-12 16:03:25 +00:00
|
|
|
return state->priv->target_state_name;
|
|
|
|
}
|
2010-05-21 13:13:14 +00:00
|
|
|
|
|
|
|
typedef struct _ParseClosure {
|
|
|
|
ClutterState *state;
|
|
|
|
ClutterScript *script;
|
|
|
|
|
|
|
|
GValue *value;
|
|
|
|
|
|
|
|
gboolean result;
|
|
|
|
} ParseClosure;
|
|
|
|
|
|
|
|
static void
|
|
|
|
parse_state_transition (JsonArray *array,
|
|
|
|
guint index_,
|
|
|
|
JsonNode *element,
|
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
ParseClosure *clos = data;
|
|
|
|
JsonObject *object;
|
|
|
|
const gchar *source_name, *target_name;
|
|
|
|
State *source_state, *target_state;
|
|
|
|
JsonArray *keys;
|
|
|
|
GSList *valid_keys = NULL;
|
2010-08-13 11:12:59 +00:00
|
|
|
GList *array_keys, *k;
|
2010-05-21 13:13:14 +00:00
|
|
|
|
|
|
|
if (JSON_NODE_TYPE (element) != JSON_NODE_OBJECT)
|
|
|
|
{
|
|
|
|
g_warning ("The 'transitions' member of a ClutterState description "
|
|
|
|
"should be an array of objects, but the element %d of the "
|
|
|
|
"array is of type '%s'. The element will be ignored.",
|
|
|
|
index_,
|
|
|
|
json_node_type_name (element));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
object = json_node_get_object (element);
|
|
|
|
|
|
|
|
if (!json_object_has_member (object, "source") ||
|
|
|
|
!json_object_has_member (object, "target") ||
|
2010-09-15 13:59:39 +00:00
|
|
|
!(json_object_has_member (object, "keys") ||
|
|
|
|
json_object_has_member (object, "animator")))
|
2010-05-21 13:13:14 +00:00
|
|
|
{
|
|
|
|
g_warning ("The transition description at index %d is missing one "
|
2010-09-15 13:59:39 +00:00
|
|
|
"of the mandatory members: source, target and keys or "
|
|
|
|
"animator", index_);
|
2010-05-21 13:13:14 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
source_name = json_object_get_string_member (object, "source");
|
2010-07-02 15:44:54 +00:00
|
|
|
source_state = clutter_state_fetch_state (clos->state, source_name, TRUE);
|
2010-05-21 13:13:14 +00:00
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
target_name = json_object_get_string_member (object, "target");
|
2010-07-02 15:44:54 +00:00
|
|
|
target_state = clutter_state_fetch_state (clos->state, target_name, TRUE);
|
2010-05-21 13:13:14 +00:00
|
|
|
|
|
|
|
if (json_object_has_member (object, "duration"))
|
|
|
|
{
|
|
|
|
guint duration = json_object_get_int_member (object, "duration");
|
|
|
|
|
|
|
|
clutter_state_set_duration (clos->state,
|
2010-05-26 12:43:42 +00:00
|
|
|
source_name, target_name,
|
2010-05-21 13:13:14 +00:00
|
|
|
duration);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (json_object_has_member (object, "animator"))
|
|
|
|
{
|
2011-02-15 11:50:26 +00:00
|
|
|
const gchar *id_ = json_object_get_string_member (object, "animator");
|
2010-05-21 13:13:14 +00:00
|
|
|
GObject *animator;
|
|
|
|
|
2011-02-15 11:50:26 +00:00
|
|
|
animator = clutter_script_get_object (clos->script, id_);
|
2010-05-21 13:13:14 +00:00
|
|
|
if (animator == NULL)
|
|
|
|
{
|
2011-02-15 11:50:26 +00:00
|
|
|
g_warning ("No object with id '%s' has been defined.", id_);
|
2010-05-21 13:13:14 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
clutter_state_set_animator (clos->state,
|
|
|
|
source_name,
|
|
|
|
target_name,
|
|
|
|
CLUTTER_ANIMATOR (animator));
|
|
|
|
}
|
|
|
|
|
2010-09-15 13:59:39 +00:00
|
|
|
if (!json_object_has_member (object, "keys"))
|
|
|
|
return;
|
|
|
|
|
|
|
|
keys = json_object_get_array_member (object, "keys");
|
|
|
|
if (keys == NULL && !json_object_has_member (object, "animator"))
|
|
|
|
{
|
|
|
|
g_warning ("The transition description at index %d has an invalid "
|
|
|
|
"key member of type '%s' when an array was expected.",
|
|
|
|
index_,
|
|
|
|
json_node_type_name (json_object_get_member (object, "keys")));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-05-21 13:13:14 +00:00
|
|
|
if (G_IS_VALUE (clos->value))
|
|
|
|
valid_keys = g_slist_reverse (g_value_get_pointer (clos->value));
|
|
|
|
else
|
|
|
|
g_value_init (clos->value, G_TYPE_POINTER);
|
|
|
|
|
2010-08-13 11:12:59 +00:00
|
|
|
array_keys = json_array_get_elements (keys);
|
|
|
|
for (k = array_keys; k != NULL; k = k->next)
|
2010-05-21 13:13:14 +00:00
|
|
|
{
|
|
|
|
JsonNode *node = k->data;
|
|
|
|
JsonArray *key = json_node_get_array (node);
|
|
|
|
ClutterStateKey *state_key;
|
|
|
|
GObject *gobject;
|
|
|
|
GParamSpec *pspec;
|
2011-02-15 11:50:26 +00:00
|
|
|
const gchar *id_;
|
2010-05-21 13:13:14 +00:00
|
|
|
const gchar *property;
|
|
|
|
gulong mode;
|
|
|
|
gboolean res;
|
|
|
|
|
2011-02-15 11:50:26 +00:00
|
|
|
id_ = json_array_get_string_element (key, 0);
|
|
|
|
gobject = clutter_script_get_object (clos->script, id_);
|
2010-05-21 13:13:14 +00:00
|
|
|
if (gobject == NULL)
|
|
|
|
{
|
2011-02-15 11:50:26 +00:00
|
|
|
g_warning ("No object with id '%s' has been defined.", id_);
|
2010-05-21 13:13:14 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
property = json_array_get_string_element (key, 1);
|
2011-07-15 14:06:31 +00:00
|
|
|
pspec = get_property_from_object (gobject, property);
|
2010-05-21 13:13:14 +00:00
|
|
|
if (pspec == NULL)
|
|
|
|
{
|
|
|
|
g_warning ("The object of type '%s' and name '%s' has no "
|
|
|
|
"property named '%s'.",
|
|
|
|
G_OBJECT_TYPE_NAME (gobject),
|
2011-02-15 11:50:26 +00:00
|
|
|
id_,
|
2010-05-21 13:13:14 +00:00
|
|
|
property);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-09-07 15:14:10 +00:00
|
|
|
mode = _clutter_script_resolve_animation_mode (json_array_get_element (key, 2));
|
2010-05-21 13:13:14 +00:00
|
|
|
|
|
|
|
state_key = clutter_state_key_new (target_state,
|
|
|
|
gobject, property, pspec,
|
|
|
|
mode);
|
|
|
|
|
2011-09-07 15:14:10 +00:00
|
|
|
res = _clutter_script_parse_node (clos->script,
|
|
|
|
&(state_key->value),
|
|
|
|
property,
|
|
|
|
json_array_get_element (key, 3),
|
|
|
|
pspec);
|
2010-05-21 13:13:14 +00:00
|
|
|
if (!res)
|
|
|
|
{
|
|
|
|
g_warning ("Unable to parse the key value for the "
|
|
|
|
"property '%s' of object '%s' at index %d",
|
|
|
|
property,
|
2011-02-15 11:50:26 +00:00
|
|
|
id_,
|
2010-05-21 13:13:14 +00:00
|
|
|
index_);
|
|
|
|
clutter_state_key_free (state_key);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-05-26 12:43:42 +00:00
|
|
|
switch (json_array_get_length (key))
|
2010-05-21 13:13:14 +00:00
|
|
|
{
|
2010-05-26 12:43:42 +00:00
|
|
|
case 5:
|
2010-05-21 13:13:14 +00:00
|
|
|
state_key->pre_delay = json_array_get_double_element (key, 4);
|
|
|
|
state_key->post_delay = 0.0;
|
2010-05-26 12:43:42 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 6:
|
2010-05-21 13:13:14 +00:00
|
|
|
state_key->pre_delay = json_array_get_double_element (key, 4);
|
|
|
|
state_key->post_delay = json_array_get_double_element (key, 5);
|
2010-05-26 12:43:42 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2010-05-21 13:13:14 +00:00
|
|
|
state_key->pre_delay = 0.0;
|
|
|
|
state_key->post_delay = 0.0;
|
2010-05-26 12:43:42 +00:00
|
|
|
break;
|
2010-05-21 13:13:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
state_key->source_state = source_state;
|
|
|
|
|
|
|
|
valid_keys = g_slist_prepend (valid_keys, state_key);
|
|
|
|
}
|
|
|
|
|
2010-08-13 11:12:59 +00:00
|
|
|
g_list_free (array_keys);
|
|
|
|
|
2010-05-21 13:13:14 +00:00
|
|
|
g_value_set_pointer (clos->value, g_slist_reverse (valid_keys));
|
|
|
|
|
|
|
|
clos->result = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
clutter_state_parse_custom_node (ClutterScriptable *scriptable,
|
|
|
|
ClutterScript *script,
|
|
|
|
GValue *value,
|
|
|
|
const gchar *name,
|
|
|
|
JsonNode *node)
|
|
|
|
{
|
|
|
|
ParseClosure clos;
|
|
|
|
|
|
|
|
if (strcmp (name, "transitions") != 0)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (JSON_NODE_TYPE (node) != JSON_NODE_ARRAY)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
clos.state = CLUTTER_STATE (scriptable);
|
|
|
|
clos.script = script;
|
|
|
|
clos.value = value;
|
|
|
|
clos.result = FALSE;
|
|
|
|
|
|
|
|
json_array_foreach_element (json_node_get_array (node),
|
|
|
|
parse_state_transition,
|
|
|
|
&clos);
|
|
|
|
|
|
|
|
return clos.result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_state_set_custom_property (ClutterScriptable *scriptable,
|
|
|
|
ClutterScript *script,
|
|
|
|
const gchar *name,
|
|
|
|
const GValue *value)
|
|
|
|
{
|
|
|
|
if (strcmp (name, "transitions") == 0)
|
|
|
|
{
|
|
|
|
ClutterState *state = CLUTTER_STATE (scriptable);
|
|
|
|
GSList *keys = g_value_get_pointer (value);
|
|
|
|
GSList *k;
|
|
|
|
|
|
|
|
for (k = keys; k != NULL; k = k->next)
|
|
|
|
clutter_state_set_key_internal (state, k->data);
|
|
|
|
|
|
|
|
g_slist_free (keys);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
g_object_set_property (G_OBJECT (scriptable), name, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_scriptable_iface_init (ClutterScriptableIface *iface)
|
|
|
|
{
|
|
|
|
iface->parse_custom_node = clutter_state_parse_custom_node;
|
|
|
|
iface->set_custom_property = clutter_state_set_custom_property;
|
|
|
|
}
|