360 lines
11 KiB
C
360 lines
11 KiB
C
/*
|
|
* Clutter.
|
|
*
|
|
* An OpenGL based 'interactive canvas' library.
|
|
*
|
|
* Copyright (C) 2012 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-property-transition
|
|
* @Title: ClutterPropertyTransition
|
|
* @Short_Description: Property transitions
|
|
*
|
|
* #ClutterPropertyTransition is a specialized #ClutterTransition that
|
|
* can be used to tween a property of a #ClutterAnimatable instance.
|
|
*
|
|
* #ClutterPropertyTransition is available since Clutter 1.10
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "clutter-property-transition.h"
|
|
|
|
#include "clutter-animatable.h"
|
|
#include "clutter-debug.h"
|
|
#include "clutter-interval.h"
|
|
#include "clutter-private.h"
|
|
#include "clutter-transition.h"
|
|
|
|
struct _ClutterPropertyTransitionPrivate
|
|
{
|
|
char *property_name;
|
|
|
|
GParamSpec *pspec;
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
|
|
PROP_PROPERTY_NAME,
|
|
|
|
PROP_LAST
|
|
};
|
|
|
|
static GParamSpec *obj_props[PROP_LAST] = { NULL, };
|
|
|
|
G_DEFINE_TYPE_WITH_PRIVATE (ClutterPropertyTransition, clutter_property_transition, CLUTTER_TYPE_TRANSITION)
|
|
|
|
static inline void
|
|
clutter_property_transition_ensure_interval (ClutterPropertyTransition *transition,
|
|
ClutterAnimatable *animatable,
|
|
ClutterInterval *interval)
|
|
{
|
|
ClutterPropertyTransitionPrivate *priv = transition->priv;
|
|
GValue *value_p;
|
|
|
|
if (clutter_interval_is_valid (interval))
|
|
return;
|
|
|
|
/* if no initial value has been set, use the current value */
|
|
value_p = clutter_interval_peek_initial_value (interval);
|
|
if (!G_IS_VALUE (value_p))
|
|
{
|
|
g_value_init (value_p, clutter_interval_get_value_type (interval));
|
|
clutter_animatable_get_initial_state (animatable,
|
|
priv->property_name,
|
|
value_p);
|
|
}
|
|
|
|
/* if no final value has been set, use the current value */
|
|
value_p = clutter_interval_peek_final_value (interval);
|
|
if (!G_IS_VALUE (value_p))
|
|
{
|
|
g_value_init (value_p, clutter_interval_get_value_type (interval));
|
|
clutter_animatable_get_initial_state (animatable,
|
|
priv->property_name,
|
|
value_p);
|
|
}
|
|
}
|
|
|
|
static void
|
|
clutter_property_transition_attached (ClutterTransition *transition,
|
|
ClutterAnimatable *animatable)
|
|
{
|
|
ClutterPropertyTransition *self = CLUTTER_PROPERTY_TRANSITION (transition);
|
|
ClutterPropertyTransitionPrivate *priv = self->priv;
|
|
ClutterInterval *interval;
|
|
|
|
if (priv->property_name == NULL)
|
|
return;
|
|
|
|
priv->pspec =
|
|
clutter_animatable_find_property (animatable, priv->property_name);
|
|
|
|
if (priv->pspec == NULL)
|
|
return;
|
|
|
|
interval = clutter_transition_get_interval (transition);
|
|
if (interval == NULL)
|
|
return;
|
|
|
|
clutter_property_transition_ensure_interval (self, animatable, interval);
|
|
}
|
|
|
|
static void
|
|
clutter_property_transition_detached (ClutterTransition *transition,
|
|
ClutterAnimatable *animatable)
|
|
{
|
|
ClutterPropertyTransition *self = CLUTTER_PROPERTY_TRANSITION (transition);
|
|
ClutterPropertyTransitionPrivate *priv = self->priv;
|
|
|
|
priv->pspec = NULL;
|
|
}
|
|
|
|
static void
|
|
clutter_property_transition_compute_value (ClutterTransition *transition,
|
|
ClutterAnimatable *animatable,
|
|
ClutterInterval *interval,
|
|
gdouble progress)
|
|
{
|
|
ClutterPropertyTransition *self = CLUTTER_PROPERTY_TRANSITION (transition);
|
|
ClutterPropertyTransitionPrivate *priv = self->priv;
|
|
GValue value = G_VALUE_INIT;
|
|
GType p_type, i_type;
|
|
gboolean res;
|
|
|
|
/* if we have a GParamSpec we also have an animatable instance */
|
|
if (priv->pspec == NULL)
|
|
return;
|
|
|
|
clutter_property_transition_ensure_interval (self, animatable, interval);
|
|
|
|
p_type = G_PARAM_SPEC_VALUE_TYPE (priv->pspec);
|
|
i_type = clutter_interval_get_value_type (interval);
|
|
|
|
g_value_init (&value, i_type);
|
|
|
|
res = clutter_animatable_interpolate_value (animatable,
|
|
priv->property_name,
|
|
interval,
|
|
progress,
|
|
&value);
|
|
|
|
if (res)
|
|
{
|
|
if (i_type != p_type || g_type_is_a (i_type, p_type))
|
|
{
|
|
if (g_value_type_transformable (i_type, p_type))
|
|
{
|
|
GValue transform = G_VALUE_INIT;
|
|
|
|
g_value_init (&transform, p_type);
|
|
|
|
if (g_value_transform (&value, &transform))
|
|
{
|
|
clutter_animatable_set_final_state (animatable,
|
|
priv->property_name,
|
|
&transform);
|
|
}
|
|
else
|
|
g_warning ("%s: Unable to convert a value of type '%s' from "
|
|
"the value type '%s' of the interval.",
|
|
G_STRLOC,
|
|
g_type_name (p_type),
|
|
g_type_name (i_type));
|
|
|
|
g_value_unset (&transform);
|
|
}
|
|
}
|
|
else
|
|
clutter_animatable_set_final_state (animatable,
|
|
priv->property_name,
|
|
&value);
|
|
}
|
|
|
|
g_value_unset (&value);
|
|
}
|
|
|
|
static void
|
|
clutter_property_transition_set_property (GObject *gobject,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
ClutterPropertyTransition *self = CLUTTER_PROPERTY_TRANSITION (gobject);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_PROPERTY_NAME:
|
|
clutter_property_transition_set_property_name (self,
|
|
g_value_get_string (value));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
clutter_property_transition_get_property (GObject *gobject,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
ClutterPropertyTransitionPrivate *priv = CLUTTER_PROPERTY_TRANSITION (gobject)->priv;
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_PROPERTY_NAME:
|
|
g_value_set_string (value, priv->property_name);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
clutter_property_transition_finalize (GObject *gobject)
|
|
{
|
|
ClutterPropertyTransitionPrivate *priv;
|
|
|
|
priv = CLUTTER_PROPERTY_TRANSITION (gobject)->priv;
|
|
|
|
g_free (priv->property_name);
|
|
|
|
G_OBJECT_CLASS (clutter_property_transition_parent_class)->finalize (gobject);
|
|
}
|
|
|
|
static void
|
|
clutter_property_transition_class_init (ClutterPropertyTransitionClass *klass)
|
|
{
|
|
ClutterTransitionClass *transition_class = CLUTTER_TRANSITION_CLASS (klass);
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
transition_class->attached = clutter_property_transition_attached;
|
|
transition_class->detached = clutter_property_transition_detached;
|
|
transition_class->compute_value = clutter_property_transition_compute_value;
|
|
|
|
gobject_class->set_property = clutter_property_transition_set_property;
|
|
gobject_class->get_property = clutter_property_transition_get_property;
|
|
gobject_class->finalize = clutter_property_transition_finalize;
|
|
|
|
/**
|
|
* ClutterPropertyTransition:property-name:
|
|
*
|
|
* The name of the property of a #ClutterAnimatable to animate.
|
|
*
|
|
* Since: 1.10
|
|
*/
|
|
obj_props[PROP_PROPERTY_NAME] =
|
|
g_param_spec_string ("property-name",
|
|
P_("Property Name"),
|
|
P_("The name of the property to animate"),
|
|
NULL,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
|
|
|
|
g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
|
|
}
|
|
|
|
static void
|
|
clutter_property_transition_init (ClutterPropertyTransition *self)
|
|
{
|
|
self->priv = clutter_property_transition_get_instance_private (self);
|
|
}
|
|
|
|
/**
|
|
* clutter_property_transition_new:
|
|
* @property_name: (allow-none): a property of @animatable, or %NULL
|
|
*
|
|
* Creates a new #ClutterPropertyTransition.
|
|
*
|
|
* Return value: (transfer full): the newly created #ClutterPropertyTransition.
|
|
* Use g_object_unref() when done
|
|
*
|
|
* Since: 1.10
|
|
*/
|
|
ClutterTransition *
|
|
clutter_property_transition_new (const char *property_name)
|
|
{
|
|
return g_object_new (CLUTTER_TYPE_PROPERTY_TRANSITION,
|
|
"property-name", property_name,
|
|
NULL);
|
|
}
|
|
|
|
/**
|
|
* clutter_property_transition_set_property_name:
|
|
* @transition: a #ClutterPropertyTransition
|
|
* @property_name: (allow-none): a property name
|
|
*
|
|
* Sets the #ClutterPropertyTransition:property-name property of @transition.
|
|
*
|
|
* Since: 1.10
|
|
*/
|
|
void
|
|
clutter_property_transition_set_property_name (ClutterPropertyTransition *transition,
|
|
const char *property_name)
|
|
{
|
|
ClutterPropertyTransitionPrivate *priv;
|
|
ClutterAnimatable *animatable;
|
|
|
|
g_return_if_fail (CLUTTER_IS_PROPERTY_TRANSITION (transition));
|
|
|
|
priv = transition->priv;
|
|
|
|
if (g_strcmp0 (priv->property_name, property_name) == 0)
|
|
return;
|
|
|
|
g_free (priv->property_name);
|
|
priv->property_name = g_strdup (property_name);
|
|
priv->pspec = NULL;
|
|
|
|
animatable =
|
|
clutter_transition_get_animatable (CLUTTER_TRANSITION (transition));
|
|
if (animatable != NULL)
|
|
{
|
|
priv->pspec = clutter_animatable_find_property (animatable,
|
|
priv->property_name);
|
|
}
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (transition),
|
|
obj_props[PROP_PROPERTY_NAME]);
|
|
}
|
|
|
|
/**
|
|
* clutter_property_transition_get_property_name:
|
|
* @transition: a #ClutterPropertyTransition
|
|
*
|
|
* Retrieves the value of the #ClutterPropertyTransition:property-name
|
|
* property.
|
|
*
|
|
* Return value: the name of the property being animated, or %NULL if
|
|
* none is set. The returned string is owned by the @transition and
|
|
* it should not be freed.
|
|
*
|
|
* Since: 1.10
|
|
*/
|
|
const char *
|
|
clutter_property_transition_get_property_name (ClutterPropertyTransition *transition)
|
|
{
|
|
g_return_val_if_fail (CLUTTER_IS_PROPERTY_TRANSITION (transition), NULL);
|
|
|
|
return transition->priv->property_name;
|
|
}
|