Adds action to the list of actions applied to self
A ClutterAction can only belong to one actor at a time
The ClutterActor will hold a reference on action until either
clutter_actor_remove_action() or clutter_actor_clear_actions()
is called

Parameters:

Clutter.Action action Required (not null)

a ClutterAction

Returns:

none

A convenience function for setting the name of a ClutterAction
while adding it to the list of actions applied to self
This function is the logical equivalent of:
|[
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (action), name);
clutter_actor_add_action (self, action);
]|

Parameters:

String name Required (not null)

the name to set on the action

Clutter.Action action Required (not null)

a ClutterAction

Returns:

none

Adds constraint to the list of ClutterConstraints applied
to self
The ClutterActor will hold a reference on the constraint until
either clutter_actor_remove_constraint() or
clutter_actor_clear_constraints() is called.

Parameters:

Clutter.Constraint constraint Required (not null)

a ClutterConstraint

Returns:

none

A convenience function for setting the name of a ClutterConstraint
while adding it to the list of constraints applied to self
This function is the logical equivalent of:
|[
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), name);
clutter_actor_add_constraint (self, constraint);
]|

Parameters:

String name Required (not null)

the name to set on the constraint

Clutter.Constraint constraint Required (not null)

a ClutterConstraint

Returns:

none

Adds effect to the list of ClutterEffects applied to self
The ClutterActor will hold a reference on the effect until either
clutter_actor_remove_effect() or clutter_actor_clear_effects() is
called.

Parameters:

Clutter.Effect effect Required (not null)

a ClutterEffect

Returns:

none

A convenience function for setting the name of a ClutterEffect
while adding it to the list of effectss applied to self
This function is the logical equivalent of:
|[
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (effect), name);
clutter_actor_add_effect (self, effect);
]|

Parameters:

String name Required (not null)

the name to set on the effect

Clutter.Effect effect Required (not null)

a ClutterEffect

Returns:

none

Called by the parent of an actor to assign the actor its size.
Should never be called by applications (except when implementing
a container or layout manager).
Actors can know from their allocation box whether they have moved
with respect to their parent actor. The flags parameter describes
additional information about the allocation, for instance whether
the parent has moved with respect to the stage, for example because
a grandparent's origin has moved.

Parameters:

Clutter.ActorBox box Required (not null)

new allocation of the actor, in parent-relative coordinates

Clutter.AllocationFlags flags Required (not null)

flags that control the allocation

Returns:

none

Parameters:

Clutter.ActorBox box Required (not null)

gdouble x_align Required (not null)

gdouble y_align Required (not null)

gboolean x_fill Required (not null)

gboolean y_fill Required (not null)

Clutter.AllocationFlags flags Required (not null)

Returns:

none

Allocates self taking into account the ClutterActor's
preferred size, but limiting it to the maximum available width
and height provided.
This function will do the right thing when dealing with the
actor's request mode.
The implementation of this function is equivalent to:
|[
if (request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
clutter_actor_get_preferred_width (self, available_height,
&min_width,
&natural_width);
width = CLAMP (natural_width, min_width, available_width);
clutter_actor_get_preferred_height (self, width,
&min_height,
&natural_height);
height = CLAMP (natural_height, min_height, available_height);
}
else
{
clutter_actor_get_preferred_height (self, available_width,
&min_height,
&natural_height);
height = CLAMP (natural_height, min_height, available_height);
clutter_actor_get_preferred_width (self, height,
&min_width,
&natural_width);
width = CLAMP (natural_width, min_width, available_width);
}
box.x1 = x; box.y1 = y;
box.x2 = box.x1 + available_width;
box.y2 = box.y1 + available_height;
clutter_actor_allocate (self, &box, flags);
]|
This function can be used by fluid layout managers to allocate
an actor's preferred size without making it bigger than the area
available for the container.

Parameters:

gfloat x Required (not null)

the actor's X coordinate

gfloat y Required (not null)

the actor's Y coordinate

gfloat available_width Required (not null)

the maximum available width, or -1 to use the actor's natural width

gfloat available_height Required (not null)

the maximum available height, or -1 to use the actor's natural height

Clutter.AllocationFlags flags Required (not null)

flags controlling the allocation

Returns:

none

Allocates the natural size of self.
This function is a utility call for ClutterActor implementations
that allocates the actor's preferred natural size. It can be used
by fixed layout managers (like ClutterGroup or so called
'composite actors') inside the ClutterActor::allocate
implementation to give each child exactly how much space it
requires.
This function is not meant to be used by applications. It is also
not meant to be used outside the implementation of the
ClutterActor::allocate virtual function.

Parameters:

Clutter.AllocationFlags flags Required (not null)

flags controlling the allocation

Returns:

none

Returns:

none

Parameters:

guint32 delay Required (not null)

Returns:

none

Returns:

none

Parameters:

guint32 delay Required (not null)

Returns:

none

Calls the animate_property() virtual function for animatable.
The initial_value and final_value GValues must contain
the same type; value must have been initialized to the same
type of initial_value and final_value.
All implementation of the ClutterAnimatable interface must
implement this function.
be applied to the ClutterAnimatable, and FALSE otherwise

Parameters:

Clutter.Animation animation Required (not null)

a ClutterAnimation

String property_name Required (not null)

the name of the animated property

GObject.Value initial_value Required (not null)

the initial value of the animation interval

GObject.Value final_value Required (not null)

the final value of the animation interval

gdouble progress Required (not null)

the progress factor

GObject.Value value Required (not null)

return location for the animation value

Returns:

gboolean TRUE if the value has been validated and can

Animates the given list of properties of actor between the current
value for each property and a new final value. The animation has a
definite behaviour given by the passed alpha.
See clutter_actor_animate() for further details.
This function is useful if you want to use an existing ClutterAlpha
to animate actor.
This is the vector-based variant of clutter_actor_animate_with_alpha(),
useful for language bindings.
Unlike clutter_actor_animate_with_alpha(), this function will
not allow you to specify "signal::" names and callbacks.
ClutterActor and should not be unreferenced with g_object_unref()

Parameters:

Clutter.Alpha alpha Required (not null)

a ClutterAlpha

gint32 n_properties Required (not null)

number of property names and values

Array properties Required (not null)

a vector containing the property names to set

Array values Required (not null)

a vector containing the property values to set

Returns:

Clutter.Animation a ClutterAnimation object. The object is owned by the

Animates the given list of properties of actor between the current
value for each property and a new final value. The animation has a
definite duration given by timeline and a speed given by the mode.
See clutter_actor_animate() for further details.
This function is useful if you want to use an existing timeline
to animate actor.
This is the vector-based variant of clutter_actor_animate_with_timeline(),
useful for language bindings.
Unlike clutter_actor_animate_with_timeline(), this function
will not allow you to specify "signal::" names and callbacks.
owned by the ClutterActor and should not be unreferenced with
g_object_unref()

Parameters:

guint32 mode Required (not null)

an animation mode logical id

Clutter.Timeline timeline Required (not null)

a ClutterTimeline

gint32 n_properties Required (not null)

number of property names and values

Array properties Required (not null)

a vector containing the property names to set

Array values Required (not null)

a vector containing the property values to set

Returns:

Clutter.Animation a ClutterAnimation object. The object is

Animates the given list of properties of actor between the current
value for each property and a new final value. The animation has a
definite duration and a speed given by the mode.
This is the vector-based variant of clutter_actor_animate(), useful
for language bindings.
Unlike clutter_actor_animate(), this function will not
allow you to specify "signal::" names and callbacks.
owned by the ClutterActor and should not be unreferenced with
g_object_unref()

Parameters:

guint32 mode Required (not null)

an animation mode logical id

guint32 duration Required (not null)

duration of the animation, in milliseconds

gint32 n_properties Required (not null)

number of property names and values

Array properties Required (not null)

a vector containing the property names to set

Array values Required (not null)

a vector containing the property values to set

Returns:

Clutter.Animation a ClutterAnimation object. The object is

Transforms point in coordinates relative to the actor into
ancestor-relative coordinates using the relevant transform
stack (i.e. scale, rotation, etc).
If ancestor is NULL the ancestor will be the ClutterStage. In
this case, the coordinates returned will be the coordinates on
the stage before the projection is applied. This is different from
the behaviour of clutter_actor_apply_transform_to_point().

Parameters:

Clutter.Actor ancestor

A ClutterActor ancestor, or NULL to use the default ClutterStage

Clutter.Vertex point Required (not null)

A point as ClutterVertex

Clutter.Vertex vertex Required (not null)

The translated ClutterVertex

Returns:

none

Transforms point in coordinates relative to the actor
into screen-relative coordinates with the current actor
transformation (i.e. scale, rotation, etc)

Parameters:

Clutter.Vertex point Required (not null)

A point as ClutterVertex

Clutter.Vertex vertex Required (not null)

The translated ClutterVertex

Returns:

none

Clears the list of actions applied to self

Returns:

none

Clears the list of constraints applied to self

Returns:

none

Clears the list of effects applied to self

Returns:

none

Determines if descendant is contained inside self (either as an
immediate child, or as a deeper descendant).

Parameters:

Clutter.Actor descendant Required (not null)

A ClutterActor, possibly contained in self

Returns:

gboolean whether descendent is contained within self

Creates a PangoContext for the given actor. The PangoContext
is already configured using the appropriate font map, resolution
and font options.
See also clutter_actor_get_pango_context().
on the returned value to deallocate its resources

Returns:

Pango.Context the newly created PangoContext. Use g_object_unref()

Creates a new PangoLayout from the same PangoContext used
by the ClutterActor. The PangoLayout is already configured
with the font map, resolution and font options, and the
given text.
If you want to keep around a PangoLayout created by this
function you will have to connect to the ClutterBackend::font-changed
and ClutterBackend::resolution-changed signals, and call
pango_layout_context_changed() in response to them.
when done

Parameters:

String text Required (not null)

(allow-none) the text to set on the PangoLayout, or NULL

Returns:

Pango.Layout the newly created PangoLayout. Use g_object_unref()

Destroys an actor. When an actor is destroyed, it will break any
references it holds to other objects. If the actor is inside a
container, the actor will be removed.
When you destroy a container, its children will be destroyed as well.
clutter_stage_get_default().

Returns:

none

Returns:

none

This function is used to emit an event on the main stage.
You should rarely need to use this function, except for
synthetising events.
if the actor handled the event, or FALSE if the event was
not handled

Parameters:

Clutter.Event event Required (not null)

a ClutterEvent

gboolean capture Required (not null)

TRUE if event in in capture phase, FALSE otherwise.

Returns:

gboolean the return value from the signal emission: TRUE

Finds the GParamSpec for property_name
or NULL

Parameters:

String property_name Required (not null)

the name of the animatable property to find

Returns:

GObject.ParamSpec The GParamSpec for the given property

Calculates the transformed screen coordinates of the four corners of
the actor; the returned vertices relate to the ClutterActorBox
coordinates as follows:

v[0] contains (x1, y1)
v[1] contains (x2, y1)
v[2] contains (x1, y2)
v[3] contains (x2, y2)

Returns:

Array

Returns the accessible object that describes the actor to an
assistive technology.
If no class-specific AtkObject implementation is available for the
actor instance in question, it will inherit an AtkObject
implementation from the first ancestor class for which such an
implementation is defined.
The documentation of the url="http://developer.gnome.org/doc/API/2.0/atk/index.html">ATK
library contains more information about accessible objects and
their uses.

Returns:

Atk.Object the AtkObject associated with actor

Retrieves the ClutterAction with the given name in the list
of actions applied to self
name, or NULL. The returned ClutterAction is owned by the
actor and it should not be unreferenced directly

Parameters:

String name Required (not null)

the name of the action to retrieve

Returns:

Clutter.Action a ClutterAction for the given

Retrieves the list of actions applied to self
of the list of ClutterActions. The contents of the list are
owned by the ClutterActor. Use g_list_free() to free the resources
allocated by the returned GList

Returns:

Array a copy

Gets the layout box an actor has been assigned. The allocation can
only be assumed valid inside a paint() method; anywhere else, it
may be out-of-date.
An allocation does not incorporate the actor's scale or anchor point;
those transformations do not affect layout, only rendering.
Do not call any of the clutter_actor_get_allocation_*() family
of functions inside the implementation of the get_preferred_width()
or get_preferred_height() virtual functions.

Returns:

Clutter.ActorBox

Gets the layout box an actor has been assigned. The allocation can
only be assumed valid inside a paint() method; anywhere else, it
may be out-of-date.
An allocation does not incorporate the actor's scale or anchor point;
those transformations do not affect layout, only rendering.
The returned rectangle is in pixels.

Returns:

Clutter.Geometry

Calculates the transformed coordinates of the four corners of the
actor in the plane of ancestor. The returned vertices relate to
the ClutterActorBox coordinates as follows:

verts[0] contains (x1, y1)
verts[1] contains (x2, y1)
verts[2] contains (x1, y2)
verts[3] contains (x2, y2)

If ancestor is NULL the ancestor will be the ClutterStage. In
this case, the coordinates returned will be the coordinates on
the stage before the projection is applied. This is different from
the behaviour of clutter_actor_get_abs_allocation_vertices().

Parameters:

Clutter.Actor ancestor

A ClutterActor to calculate the vertices against, or NULL to use the default ClutterStage

Returns:

Array

Gets the current anchor point of the actor in pixels.

Returns:

anchor_x: gfloat

anchor_y: gfloat

Retrieves the anchor position expressed as a ClutterGravity. If
the anchor point was specified using pixels or units this will
return CLUTTER_GRAVITY_NONE.

Returns:

Clutter.Gravity the ClutterGravity used by the anchor point

Retrieves the ClutterAnimation used by actor, if clutter_actor_animate()
has been called on actor.

Returns:

Clutter.Animation a ClutterAnimation, or NULL

Gets the clip area for self, if any is set

Returns:

xoff: gfloat

yoff: gfloat

width: gfloat

height: gfloat

Retrieves the value set using clutter_actor_set_clip_to_allocation()

Returns:

gboolean TRUE if the ClutterActor is clipped to its allocation

Retrieves the ClutterConstraint with the given name in the list
of constraints applied to self
name, or NULL. The returned ClutterConstraint is owned by the
actor and it should not be unreferenced directly

Parameters:

String name Required (not null)

the name of the constraint to retrieve

Returns:

Clutter.Constraint a ClutterConstraint for the given

Retrieves the list of constraints applied to self
of the list of ClutterConstraints. The contents of the list are
owned by the ClutterActor. Use g_list_free() to free the resources
allocated by the returned GList

Returns:

Array a copy

Retrieves the depth of self.

Returns:

gfloat the depth of the actor

Returns:

gboolean

Retrieves the ClutterEffect with the given name in the list
of effects applied to self
name, or NULL. The returned ClutterEffect is owned by the
actor and it should not be unreferenced directly

Parameters:

String name Required (not null)

the name of the effect to retrieve

Returns:

Clutter.Effect a ClutterEffect for the given

Retrieves the ClutterEffects applied on self, if any
of ClutterEffects, or NULL. The elements of the returned
list are owned by Clutter and they should not be freed. You should
free the returned list using g_list_free() when done

Returns:

Array a list

Checks whether an actor has a fixed position set (and will thus be
unaffected by any layout manager).

Returns:

gboolean TRUE if the fixed position is set on the actor

Retrieves the flags set on self

Returns:

Clutter.ActorFlags a bitwise or of ClutterActorFlags or 0

Gets the size and position of an actor relative to its parent
actor. This is the same as calling clutter_actor_get_position() and
clutter_actor_get_size(). It tries to "do what you mean" and get the
requested size and position if the actor's allocation is invalid.

Returns:

Clutter.Geometry

Retrieves the unique id for self.

Returns:

guint32 Globally unique value for this object instance.

Retrieves the height of a ClutterActor.
If the actor has a valid allocation, this function will return the
height of the allocated area given to the actor.
If the actor does not have a valid allocation, this function will
return the actor's natural height, that is the preferred height of
the actor.
If you care whether you get the preferred height or the height that
has been assigned to the actor, you should probably call a different
function like clutter_actor_get_allocation_box() to retrieve the
allocated size or clutter_actor_get_preferred_height() to retrieve the
preferred height.
If an actor has a fixed height, for instance a height that has been
assigned using clutter_actor_set_height(), the height returned will
be the same value.

Returns:

gfloat the height of the actor, in pixels

Retrieves the id of scriptable set using clutter_scriptable_set_id().
the scriptable object and should never be modified of freed

Returns:

String the id of the object. The returned string is owned by

Retrieves the current state of property_name and sets value with it

Parameters:

String property_name Required (not null)

the name of the animatable property to retrieve

GObject.Value value Required (not null)

a GValue initialized to the type of the property to retrieve

Returns:

none

Returns:

gdouble

Returns:

gdouble

Retrieves the name of self.
owned by the actor and should not be modified or freed.

Returns:

String the name of the actor, or NULL. The returned string is

Retrieves the opacity value of an actor, as set by
clutter_actor_set_opacity().
For retrieving the absolute opacity of the actor inside a paint
virtual function, see clutter_actor_get_paint_opacity().

Returns:

guint8 the opacity of the actor

Parameters:

Object out_values

Clutter.ActorBox box

Returns:

gboolean

Retrieves the absolute opacity of the actor, as it appears on the stage.
This function traverses the hierarchy chain and composites the opacity of
the actor with that of its parents.
This function is intended for subclasses to use in the paint virtual
function, to paint themselves with the correct opacity.

Returns:

guint8 The actor opacity value.

Retrieves the 'paint' visibility of an actor recursively checking for non
visible parents.
This is by definition the same as CLUTTER_ACTOR_IS_MAPPED().

Returns:

gboolean TRUE if the actor is visibile and will be painted.

Returns:

Clutter.PaintVolume

Retrieves the PangoContext for self. The actor's PangoContext
is already configured using the appropriate font map, resolution
and font options.
Unlike clutter_actor_create_pango_context(), this context is owend
by the ClutterActor and it will be updated each time the options
stored by the ClutterBackend change.
You can use the returned PangoContext to create a PangoLayout
and render text using cogl_pango_render_layout() to reuse the
glyphs cache also used by Clutter.
The returned PangoContext is owned by the actor and should not be
unreferenced by the application code

Returns:

Pango.Context the PangoContext for a ClutterActor.

Retrieves the parent of self.
if no parent is set

Returns:

Clutter.Actor The ClutterActor parent, or NULL

This function tries to "do what you mean" and tell you where the
actor is, prior to any transformations. Retrieves the fixed
position of an actor in pixels, if one has been set; otherwise, if
the allocation is valid, returns the actor's allocated position;
otherwise, returns 0,0.
The returned position is in pixels.

Returns:

x: gfloat

y: gfloat

Computes the requested minimum and natural heights for an actor,
or if they are already computed, returns the cached values.
An actor may not get its request - depending on the layout
manager that's in effect.
A request should not incorporate the actor's scale or anchor point;
those transformations do not affect layout, only rendering.

Parameters:

gfloat for_width Required (not null)

available width to assume in computing desired height, or a negative value to indicate that no width is defined

Returns:

min_height_p: gfloat

natural_height_p: gfloat

Computes the preferred minimum and natural size of an actor, taking into
account the actor's geometry management (either height-for-width
or width-for-height).
The width and height used to compute the preferred height and preferred
width are the actor's natural ones.
If you need to control the height for the preferred width, or the width for
the preferred height, you should use clutter_actor_get_preferred_width()
and clutter_actor_get_preferred_height(), and check the actor's preferred
geometry management using the ClutterActor:request-mode property.

Returns:

min_width_p: gfloat

min_height_p: gfloat

natural_width_p: gfloat

natural_height_p: gfloat

Computes the requested minimum and natural widths for an actor,
optionally depending on the specified height, or if they are
already computed, returns the cached values.
An actor may not get its request - depending on the layout
manager that's in effect.
A request should not incorporate the actor's scale or anchor point;
those transformations do not affect layout, only rendering.

Parameters:

gfloat for_height Required (not null)

available height when computing the preferred width, or a negative value to indicate that no height is defined

Returns:

min_width_p: gfloat

natural_width_p: gfloat

Checks whether actor is marked as reactive.

Returns:

gboolean TRUE if the actor is reactive

Retrieves the geometry request mode of self

Returns:

Clutter.RequestMode the request mode for the actor

Retrieves the angle and center of rotation on the given axis,
set using clutter_actor_set_rotation().

Parameters:

Clutter.RotateAxis axis Required (not null)

the axis of rotation

Object out_values

gfloat x

gfloat y

gfloat z

Returns:

gdouble the angle of rotation

Retrieves an actors scale factors.

Returns:

scale_x: gdouble

scale_y: gdouble

Retrieves the scale center coordinate in pixels relative to the top
left corner of the actor. If the scale center was specified using a
ClutterGravity this will calculate the pixel offset using the
current size of the actor.

Returns:

center_x: gfloat

center_y: gfloat

Retrieves the scale center as a compass direction. If the scale
center was specified in pixels or units this will return
CLUTTER_GRAVITY_NONE.

Returns:

Clutter.Gravity the scale gravity

Returns:

gboolean

Returns:

gboolean

Queries the currently set ClutterShader on self.
or NULL if no shader is set.

Returns:

Clutter.Shader The currently set ClutterShader

Retrieves the ClutterStage where actor is contained.

Returns:

Clutter.Actor the stage containing the actor, or NULL

Retrieves the value set using clutter_actor_set_text_direction()
If no text direction has been previously set, the default text
direction, as returned by clutter_get_default_text_direction(), will
be returned instead

Returns:

Clutter.TextDirection the ClutterTextDirection for the actor

Retrieves the transformations applied to self

Returns:

Cogl.Matrix

Parameters:

Clutter.Actor relative_to_ancestor Required (not null)

Returns:

Clutter.PaintVolume

Gets the absolute position of an actor, in pixels relative to the stage.

Returns:

x: gfloat

y: gfloat

Gets the absolute size of an actor in pixels, taking into account the
scaling factors.
If the actor has a valid allocation, the allocated size will be used.
If the actor has not a valid allocation then the preferred size will
be transformed and returned.
If you want the transformed allocation, see
clutter_actor_get_abs_allocation_vertices() instead.
When the actor (or one of its ancestors) is rotated around the
X or Y axis, it no longer appears as on the stage as a rectangle, but
as a generic quadrangle; in that case this function returns the size
of the smallest rectangle that encapsulates the entire quad. Please
note that in this case no assumptions can be made about the relative
position of this envelope to the absolute position of the actor, as
returned by clutter_actor_get_transformed_position(); if you need this
information, you need to use clutter_actor_get_abs_allocation_vertices()
to get the coords of the actual quadrangle.

Returns:

width: gfloat

height: gfloat

Retrieves the width of a ClutterActor.
If the actor has a valid allocation, this function will return the
width of the allocated area given to the actor.
If the actor does not have a valid allocation, this function will
return the actor's natural width, that is the preferred width of
the actor.
If you care whether you get the preferred width or the width that
has been assigned to the actor, you should probably call a different
function like clutter_actor_get_allocation_box() to retrieve the
allocated size or clutter_actor_get_preferred_width() to retrieve the
preferred width.
If an actor has a fixed width, for instance a width that has been
assigned using clutter_actor_set_width(), the width returned will
be the same value.

Returns:

gfloat the width of the actor, in pixels

Returns:

gfloat

Returns:

gfloat

Retrieves the center for the rotation around the Z axis as a
compass direction. If the center was specified in pixels or units
this will return CLUTTER_GRAVITY_NONE.

Returns:

Clutter.Gravity the Z rotation center

Sets the key focus of the ClutterStage including self
to this ClutterActor.

Returns:

none

Checks if the actor has an up-to-date allocation assigned to
visible and has a parent. It also means that there is no
outstanding relayout request in progress for the actor or its
children (There might be other outstanding layout requests in
progress that will cause the actor to get a new allocation
when the stage is laid out, however).
If this function returns FALSE, then the actor will normally
be allocated before it is next drawn on the screen.

Returns:

gboolean TRUE if the actor has an up-to-date allocation

Determines whether the actor has a clip area set or not.

Returns:

gboolean TRUE if the actor has a clip area set.

Returns:

gboolean

Checks whether an actor contains the the pointer of a
ClutterInputDevice
FALSE otherwise

Returns:

gboolean TRUE if the actor contains the pointer, and

Flags an actor to be hidden. A hidden actor will not be
rendered on the stage.
Actors are visible by default.
If this function is called on an actor without a parent, the
ClutterActor:show-on-set-parent property will be set to FALSE
as a side-effect.

Returns:

none

Calls clutter_actor_hide() on all child actors (if any).

Returns:

none

Checks whether self is being currently painted by a ClutterClone
This function is useful only inside the ::paint virtual function
implementations or within handlers for the ClutterActor::paint
signal
This function should not be used by applications
by a ClutterClone, and FALSE otherwise

Returns:

gboolean TRUE if the ClutterActor is currently being painted

Checks whether any rotation is applied to the actor.

Returns:

gboolean TRUE if the actor is rotated.

Checks whether the actor is scaled in either dimension.

Returns:

gboolean TRUE if the actor is scaled.

Puts self below above.
Both actors must have the same parent, and the parent must implement
the ClutterContainer interface.
This function is the equivalent of clutter_container_lower_child().

Parameters:

Clutter.Actor above

A ClutterActor to lower below

Returns:

none

Lowers self to the bottom.
This function calls clutter_actor_lower() internally.

Returns:

none

Sets the CLUTTER_ACTOR_MAPPED flag on the actor and possibly maps
and realizes its children if they are visible. Does nothing if the
actor is not visible.
ClutterActor::map virtual function in an actor and you need to map
the children of that actor. It is not necessary to call this
if you implement ClutterContainer because the default implementation
will automatically map children of containers.
When overriding map, it is mandatory to chain up to the parent
implementation.

Returns:

none

Sets an anchor point for the actor, and adjusts the actor postion so that
the relative position of the actor toward its parent remains the same.

Parameters:

gfloat anchor_x Required (not null)

X coordinate of the anchor point

gfloat anchor_y Required (not null)

Y coordinate of the anchor point

Returns:

none

Sets an anchor point on the actor based on the given gravity, adjusting the
actor postion so that its relative position within its parent remains
unchanged.
Since version 1.0 the anchor point will be stored as a gravity so
that if the actor changes size then the anchor point will move. For
example, if you set the anchor point to CLUTTER_GRAVITY_SOUTH_EAST
and later double the size of the actor, the anchor point will move
to the bottom right.

Parameters:

Clutter.Gravity gravity Required (not null)

ClutterGravity.

Returns:

none

Moves an actor by the specified distance relative to its current
position in pixels.
This function modifies the fixed position of an actor and thus removes
it from any layout management. Another way to move an actor is with an
anchor point, see clutter_actor_set_anchor_point().

Parameters:

gfloat dx Required (not null)

Distance to move Actor on X axis.

gfloat dy Required (not null)

Distance to move Actor on Y axis.

Returns:

none

Renders the actor to display.
This function should not be called directly by applications.
Call clutter_actor_queue_redraw() to queue paints, instead.
This function will emit the ClutterActor::paint signal.

Returns:

none

Parses the passed JSON node. The implementation must set the type
of the passed GValue pointer using g_value_init().

Parameters:

Clutter.Script script Required (not null)

the ClutterScript creating the scriptable instance

GObject.Value value Required (not null)

the generic value to be set

String name Required (not null)

the name of the node

Json.Node node Required (not null)

the JSON node to be parsed

Returns:

gboolean TRUE if the node was successfully parsed, FALSE otherwise.

Disables the effects of clutter_actor_pop_internal()

Returns:

none

Should be used by actors implementing the ClutterContainer and with
internal children added through clutter_actor_set_parent(), for instance:
|[
static void
my_actor_init (MyActor *self)
{
self->priv = SELF_ACTOR_GET_PRIVATE (self);
clutter_actor_push_internal (CLUTTER_ACTOR (self));
/* calling clutter_actor_set_parent() now will result in
* the internal flag being set on a child of MyActor
*/
/* internal child - a background texture */
self->priv->background_tex = clutter_texture_new ();
clutter_actor_set_parent (self->priv->background_tex,
CLUTTER_ACTOR (self));
/* internal child - a label */
self->priv->label = clutter_text_new ();
clutter_actor_set_parent (self->priv->label,
CLUTTER_ACTOR (self));
clutter_actor_pop_internal (CLUTTER_ACTOR (self));
/* calling clutter_actor_set_parent() now will not result in
* the internal flag being set on a child of MyActor
*/
}
]|
This function will be used by Clutter to toggle an "internal child"
flag whenever clutter_actor_set_parent() is called; internal children
are handled differently by Clutter, specifically when destroying their
parent.
Call clutter_actor_pop_internal() when you finished adding internal
children.
Nested calls to clutter_actor_push_internal() are allowed, but each
one must by followed by a clutter_actor_pop_internal() call.

Returns:

none

Queues up a redraw of an actor and any children. The redraw occurs
once the main loop becomes idle (after the current batch of events
has been processed, roughly).
Applications rarely need to call this, as redraws are handled
automatically by modification functions.
This function will not do anything if self is not visible, or
if the actor is inside an invisible part of the scenegraph.
Also be aware that painting is a NOP for actors with an opacity of
0

Returns:

none

Indicates that the actor's size request or other layout-affecting
properties may have changed. This function is used inside ClutterActor
subclass implementations, not by applications directly.
Queueing a new layout automatically queues a redraw as well.

Returns:

none

Puts self above below.
Both actors must have the same parent, and the parent must implement
the ClutterContainer interface
This function is the equivalent of clutter_container_raise_child().

Parameters:

Clutter.Actor below

A ClutterActor to raise above.

Returns:

none

Raises self to the top.
This function calls clutter_actor_raise() internally.

Returns:

none

Realization informs the actor that it is attached to a stage. It
can use this to allocate resources if it wanted to delay allocation
until it would be rendered. However it is perfectly acceptable for
an actor to create resources before being realized because Clutter
only ever has a single rendering context so that actor is free to
be moved from one stage to another.
This function does nothing if the actor is already realized.
Because a realized actor must have realized parent actors, calling
clutter_actor_realize() will also realize all parents of the actor.
This function does not realize child actors, except in the special
case that realizing the stage, when the stage is visible, will
suddenly map (and thus realize) the children of the stage.

Returns:

none

Removes action from the list of actions applied to self
The reference held by self on the ClutterAction will be released

Parameters:

Clutter.Action action Required (not null)

a ClutterAction

Returns:

none

Removes the ClutterAction with the given name from the list
of actions applied to self

Parameters:

String name Required (not null)

the name of the action to remove

Returns:

none

Returns:

none

Removes constraint from the list of constraints applied to self
The reference held by self on the ClutterConstraint will be released

Parameters:

Clutter.Constraint constraint Required (not null)

a ClutterConstraint

Returns:

none

Removes the ClutterConstraint with the given name from the list
of constraints applied to self

Parameters:

String name Required (not null)

the name of the constraint to remove

Returns:

none

Removes effect from the list of effects applied to self
The reference held by self on the ClutterEffect will be released

Parameters:

Clutter.Effect effect Required (not null)

a ClutterEffect

Returns:

none

Removes the ClutterEffect with the given name from the list
of effects applied to self

Parameters:

String name Required (not null)

the name of the effect to remove

Returns:

none

This function resets the parent actor of self. It is
logically equivalent to calling clutter_actor_unparent()
and clutter_actor_set_parent(), but more efficiently
implemented, ensures the child is not finalized
when unparented, and emits the parent-set signal only
one time.

Parameters:

Clutter.Actor new_parent Required (not null)

the new ClutterActor parent

Returns:

none

Sets an anchor point for self. The anchor point is a point in the
coordinate space of an actor to which the actor position within its
parent is relative; the default is (0, 0), i.e. the top-left corner
of the actor.

Parameters:

gfloat anchor_x Required (not null)

X coordinate of the anchor point

gfloat anchor_y Required (not null)

Y coordinate of the anchor point

Returns:

none

Sets an anchor point on the actor, based on the given gravity (this is a
convenience function wrapping clutter_actor_set_anchor_point()).
Since version 1.0 the anchor point will be stored as a gravity so
that if the actor changes size then the anchor point will move. For
example, if you set the anchor point to CLUTTER_GRAVITY_SOUTH_EAST
and later double the size of the actor, the anchor point will move
to the bottom right.

Parameters:

Clutter.Gravity gravity Required (not null)

ClutterGravity.

Returns:

none

Sets clip area for self. The clip area is always computed from the
upper left corner of the actor, even if the anchor point is set
otherwise.

Parameters:

gfloat xoff Required (not null)

X offset of the clip rectangle

gfloat yoff Required (not null)

Y offset of the clip rectangle

gfloat width Required (not null)

Width of the clip rectangle

gfloat height Required (not null)

Height of the clip rectangle

Returns:

none

Sets whether self should be clipped to the same size as its
allocation

Parameters:

gboolean clip_set Required (not null)

TRUE to apply a clip tracking the allocation

Returns:

none

Overrides the common properties setting. The underlying virtual
function should be used when implementing custom properties.

Parameters:

Clutter.Script script Required (not null)

the ClutterScript creating the scriptable instance

String name Required (not null)

the name of the property

GObject.Value value Required (not null)

the value of the property

Returns:

none

Sets the Z coordinate of self to depth.
The unit used by depth is dependant on the perspective setup. See
also clutter_stage_set_perspective().

Parameters:

gfloat depth Required (not null)

Z co-ord

Returns:

none

Parameters:

gboolean value Required (not null)

Returns:

none

Sets the current state of property_name to value

Parameters:

String property_name Required (not null)

the name of the animatable property to set

GObject.Value value Required (not null)

the value of the animatable property to set

Returns:

none

Sets whether an actor has a fixed position set (and will thus be
unaffected by any layout manager).

Parameters:

gboolean is_set Required (not null)

whether to use fixed position

Returns:

none

Sets flags on self
This function will emit notifications for the changed properties

Parameters:

Clutter.ActorFlags flags Required (not null)

the flags to set

Returns:

none

Sets the actor's fixed position and forces its minimum and natural
size, in pixels. This means the untransformed actor will have the
given geometry. This is the same as calling clutter_actor_set_position()
and clutter_actor_set_size().

Parameters:

Clutter.Geometry geometry Required (not null)

A ClutterGeometry

Returns:

none

Parameters:

gfloat height Required (not null)

Returns:

none

Sets id as the unique Clutter script it for this instance of
ClutterScriptableIface.
This name can be used by user interface designer applications to
define a unique name for an object constructable using the UI
definition language parsed by ClutterScript.

Parameters:

String id_ Required (not null)

Returns:

none

Parameters:

gdouble latitude Required (not null)

gdouble longitude Required (not null)

Returns:

none

Sets the given name to self. The name can be used to identify
a ClutterActor.

Parameters:

String name Required (not null)

Textual tag to apply to actor

Returns:

none

Sets the actor's opacity, with zero being completely transparent and
255 (0xff) being fully opaque.

Parameters:

guint8 opacity Required (not null)

New opacity value for the actor.

Returns:

none

Sets the parent of self to parent. The opposite function is
clutter_actor_unparent().
This function should not be used by applications, but by custom
container actor subclasses.

Parameters:

Clutter.Actor parent Required (not null)

A new ClutterActor parent

Returns:

none

Parameters:

gfloat x Required (not null)

gfloat y Required (not null)

Returns:

none

Sets actor as reactive. Reactive actors will receive events.

Parameters:

gboolean reactive Required (not null)

whether the actor should be reactive to events

Returns:

none

Sets the geometry request mode of self.
The mode determines the order for invoking
clutter_actor_get_preferred_width() and
clutter_actor_get_preferred_height()

Parameters:

Clutter.RequestMode mode Required (not null)

the request mode

Returns:

none

Sets the rotation angle of self around the given axis.
The rotation center coordinates used depend on the value of axis:

CLUTTER_X_AXIS requires y and z
CLUTTER_Y_AXIS requires x and z
CLUTTER_Z_AXIS requires x and y

The rotation coordinates are relative to the anchor point of the
actor, set using clutter_actor_set_anchor_point(). If no anchor
point is set, the upper left corner is assumed as the origin.

Parameters:

Clutter.RotateAxis axis Required (not null)

the axis of rotation

gdouble angle Required (not null)

the angle of rotation

gfloat x Required (not null)

X coordinate of the rotation center

gfloat y Required (not null)

Y coordinate of the rotation center

gfloat z Required (not null)

Z coordinate of the rotation center

Returns:

none

Scales an actor with the given factors. The scaling is relative to
the scale center and the anchor point. The scale center is
unchanged by this function and defaults to 0,0.

Parameters:

gdouble scale_x Required (not null)

double factor to scale actor by horizontally.

gdouble scale_y Required (not null)

double factor to scale actor by vertically.

Returns:

none

Scales an actor with the given factors around the given center
point. The center point is specified in pixels relative to the
anchor point (usually the top left corner of the actor).

Parameters:

gdouble scale_x Required (not null)

double factor to scale actor by horizontally.

gdouble scale_y Required (not null)

double factor to scale actor by vertically.

gfloat center_x Required (not null)

X coordinate of the center of the scale.

gfloat center_y Required (not null)

Y coordinate of the center of the scale

Returns:

none

Scales an actor with the given factors around the given
center point. The center point is specified as one of the compass
directions in ClutterGravity. For example, setting it to north
will cause the top of the actor to remain unchanged and the rest of
the actor to expand left, right and downwards.

Parameters:

gdouble scale_x Required (not null)

double factor to scale actor by horizontally.

gdouble scale_y Required (not null)

double factor to scale actor by vertically.

Clutter.Gravity gravity Required (not null)

the location of the scale center expressed as a compass direction.

Returns:

none

Parameters:

gboolean value Required (not null)

Returns:

none

Parameters:

gboolean value Required (not null)

Returns:

none

Sets the ClutterShader to be used when rendering self.
If shader is NULL it will unset any currently set shader
for the actor.

Parameters:

Clutter.Shader shader

a ClutterShader or NULL to unset the shader.

Returns:

gboolean TRUE if the shader was successfully applied

Sets the value for a named parameter of the shader applied
to actor.

Parameters:

String param Required (not null)

the name of the parameter

GObject.Value value Required (not null)

the value of the parameter

Returns:

none

Sets the value for a named float parameter of the shader applied
to actor.

Parameters:

String param Required (not null)

the name of the parameter

gfloat value Required (not null)

the value of the parameter

Returns:

none

Sets the value for a named int parameter of the shader applied to

Parameters:

String param Required (not null)

the name of the parameter

gint32 value Required (not null)

the value of the parameter

Returns:

none

Sets the ClutterTextDirection for an actor
The passed text direction must not be CLUTTER_TEXT_DIRECTION_DEFAULT
If self implements ClutterContainer then this function will recurse
inside all the children of self (including the internal ones).
Composite actors not implementing ClutterContainer, or actors requiring
special handling when the text direction changes, should connect to
the GObject::notify signal for the ClutterActor:text-direction property

Parameters:

Clutter.TextDirection text_dir Required (not null)

the text direction for self

Returns:

none

Parameters:

gfloat width Required (not null)

Returns:

none

Sets the actor's X coordinate, relative to its parent, in pixels.
Overrides any layout manager and forces a fixed position for
the actor.

Parameters:

gfloat x Required (not null)

the actor's position on the X axis

Returns:

none

Sets the actor's Y coordinate, relative to its parent, in pixels.#
Overrides any layout manager and forces a fixed position for
the actor.

Parameters:

gfloat y Required (not null)

the actor's position on the Y axis

Returns:

none

Sets the rotation angle of self around the Z axis using the center
point specified as a compass point. For example to rotate such that
the center of the actor remains static you can use
CLUTTER_GRAVITY_CENTER. If the actor changes size the center point
will move accordingly.

Parameters:

gdouble angle Required (not null)

the angle of rotation

Clutter.Gravity gravity Required (not null)

the center point of the rotation

Returns:

none

Should be called inside the implementation of the
ClutterActor::pick virtual function in order to check whether
the actor should paint itself in pick mode or not.
This function should never be called directly by applications.
FALSE otherwise

Returns:

gboolean TRUE if the actor should paint its silhouette,

Flags an actor to be displayed. An actor that isn't shown will not
be rendered on the stage.
Actors are visible by default.
If this function is called on an actor without a parent, the
ClutterActor:show-on-set-parent will be set to TRUE as a side
effect.

Returns:

none

Calls clutter_actor_show() on all children of an actor (if any).

Returns:

none

Parameters:

gfloat x Required (not null)

gfloat y Required (not null)

Object out_values

gfloat x_out

gfloat y_out

Returns:

gboolean

Unsets the CLUTTER_ACTOR_MAPPED flag on the actor and possibly
unmaps its children if they were mapped.
ClutterActor::unmap virtual function in an actor and you need to
unmap the children of that actor. It is not necessary to call this
if you implement ClutterContainer because the default implementation
will automatically unmap children of containers.
When overriding unmap, it is mandatory to chain up to the parent
implementation.

Returns:

none

Removes the parent of self.
This function should not be used in applications. It should be called by
implementations of container actors, to dissociate a child from the
container.

Returns:

none

Unrealization informs the actor that it may be being destroyed or
moved to another stage. The actor may want to destroy any
underlying graphics resources at this point. However it is
perfectly acceptable for it to retain the resources until the actor
is destroyed because Clutter only ever uses a single rendering
context and all of the graphics resources are valid on any stage.
Because mapped actors must be realized, actors may not be
unrealized if they are mapped. This function hides the actor to be
sure it isn't mapped, an application-visible side effect that you
may not be expecting.
This function should not really be in the public API, because
there isn't a good reason to call it. ClutterActor will already
unrealize things for you when it's important to do so.
If you were using clutter_actor_unrealize() in a dispose
implementation, then don't, just chain up to ClutterActor's
dispose.
If you were using clutter_actor_unrealize() to implement
unrealizing children of your container, then don't, ClutterActor
will already take care of that.
If you were using clutter_actor_unrealize() to re-realize to
create your resources in a different way, then use
_clutter_actor_rerealize() (inside Clutter) or just call your
code that recreates your resources directly (outside Clutter).

Returns:

none

Unsets flags on self
This function will emit notifications for the changed properties

Parameters:

Clutter.ActorFlags flags Required (not null)

the flags to unset

Returns:

none

The ::allocation-changed signal is emitted when the
ClutterActor:allocation property changes. Usually, application
code should just use the notifications for the :allocation property
but if you want to track the allocation flags as well, for instance
to know whether the absolute origin of actor changed, then you might
want use this signal instead.

Parameters:

Clutter.Actor self

Clutter.ActorBox box

Clutter.AllocationFlags flags

Returns:

{none}

Parameters:

Champlain.Marker self

Clutter.Event since

Returns:

{none}

The ::button-press-event signal is emitted each time a mouse button
is pressed on actor.
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

Parameters:

Champlain.Marker self

Clutter.Event since

Returns:

{none}

The ::button-release-event signal is emitted each time a mouse button
is released on actor.
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

The ::captured-event signal is emitted when an event is captured
by Clutter. This signal will be emitted starting from the top-level
container (the ClutterStage) to the actor which received the event
going down the hierarchy. This signal can be used to intercept every
event before the specialized events (like
ClutterActor::button-press-event or ::key-released-event) are
emitted.
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

The ::destroy signal is emitted when an actor is destroyed,
either by direct invocation of clutter_actor_destroy() or
when the ClutterGroup that contains the actor is destroyed.

Parameters:

Clutter.Actor self

Returns:

{none}

Parameters:

Champlain.Marker self

Clutter.Event since

Returns:

{none}

Parameters:

Champlain.Marker self

gdouble dy

gdouble event

Clutter.Event since

Returns:

{none}

The ::enter-event signal is emitted when the pointer enters the actor
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

The ::event signal is emitted each time an event is received
by the actor. This signal will be emitted on every actor,
following the hierarchy chain, until it reaches the top-level
container (the ClutterStage).
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

The ::hide signal is emitted when an actor is no longer rendered
on the stage.

Parameters:

Clutter.Actor self

Returns:

{none}

The ::focus-in signal is emitted when actor recieves key focus.

Parameters:

Clutter.Actor self

Returns:

{none}

The ::key-focus-out signal is emitted when actor loses key focus.

Parameters:

Clutter.Actor self

Returns:

{none}

The ::key-press-event signal is emitted each time a keyboard button
is pressed while actor has key focus (see clutter_stage_set_key_focus()).
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

The ::key-release-event signal is emitted each time a keyboard button
is released while actor has key focus (see
clutter_stage_set_key_focus()).
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

The ::leave-event signal is emitted when the pointer leaves the actor.
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

The ::motion-event signal is emitted each time the mouse pointer is
moved over actor.
or FALSE to continue the emission.

Parameters:

Clutter.Actor self

Clutter.Event event

Returns:

{gboolean}

The ::paint signal is emitted each time an actor is being painted.
Subclasses of ClutterActor should override the class signal handler
and paint themselves in that function.
It is possible to connect a handler to the ::paint signal in order
to set up some custom aspect of a paint.

Parameters:

Clutter.Actor self

Returns:

{none}

This signal is emitted when the parent of the actor changes.

Parameters:

Clutter.Actor self

Clutter.Actor old_parent

Returns:

{none}

The ::pick signal is emitted each time an actor is being painted
in "pick mode". The pick mode is used to identify the actor during
the event handling phase, or by clutter_stage_get_actor_at_pos().
The actor should paint its shape using the passed pick_color.
Subclasses of ClutterActor should override the class signal handler
and paint themselves in that function.
It is possible to connect a handler to the ::pick signal in order
to set up some custom aspect of a paint in pick mode.

Parameters:

Clutter.Actor self

Clutter.Color color

Returns:

{none}

The ::queue_redraw signal is emitted when clutter_actor_queue_redraw()
is called on origin.
The default implementation for ClutterActor chains up to the
parent actor and queues a redraw on the parent, thus "bubbling"
the redraw queue up through the actor graph. The default
implementation for ClutterStage queues a clutter_redraw() in a
main loop idle handler.
Note that the origin actor may be the stage, or a container; it
does not have to be a leaf node in the actor graph.
Toolkits embedding a ClutterStage which require a redraw and
relayout cycle can stop the emission of this signal using the
GSignal API, redraw the UI and then call clutter_redraw()
themselves, like:
|[
static void
on_redraw_complete (void)
{
/* execute the Clutter drawing pipeline */
clutter_redraw ();
}
static void
on_stage_queue_redraw (ClutterStage *stage)
{
/* this prevents the default handler to run */
g_signal_stop_emission_by_name (stage, "queue-redraw");
/* queue a redraw with the host toolkit and call
* a function when the redraw has been completed
*/
queue_a_redraw (G_CALLBACK (on_redraw_complete));
}
]|
This signal is emitted before the Clutter paint
pipeline is executed. If you want to know when the pipeline has
been completed you should connect to the ::paint signal on the
Stage with g_signal_connect_after().

Parameters:

Clutter.Actor self

Clutter.Actor origin

Returns:

{none}