Class: Clutter::Actor

Inherits:
GObject::InitiallyUnowned
  • Object
show all
Defined in:
lib/clutter/actor.rb

Overview

Base class for actors.

Direct Known Subclasses

Box, Clone, Group, Rectangle, ScrollActor, Text, Texture

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Clutter::Actor

Creates a new Clutter::Actor.

A newly created actor has a floating reference, which will be sunk
when it is added to another actor.

Instance Method Details

#accessible ⇒ Atk::Object

Returns the accessible object that describes the actor to an
assistive technology.

If no class-specific Atk::Object implementation is available for the
actor instance in question, it will inherit an Atk::Object
implementation from the first ancestor class for which such an
implementation is defined.

The documentation of the ATK
library contains more information about accessible objects and
their uses.

Returns:

  • (Atk::Object) —

    the Atk::Object associated with actor

#actions ⇒ GLib::List<Clutter::Action>

Retrieves the list of actions applied to self

Returns:

  • (GLib::List<Clutter::Action>) —

    a copy
    of the list of Clutter::Actions. The contents of the list are
    owned by the Clutter::Actor. Use g_list_free() to free the resources
    allocated by the returned #GList

#actions=(actions) ⇒ Clutter::Action

Adds a Clutter::Action to the actor

Parameters:

Returns:

#add_action(action) ⇒ nil

Adds action to the list of actions applied to self

A Clutter::Action can only belong to one actor at a time

The Clutter::Actor will hold a reference on action until either
clutter_actor_remove_action() or clutter_actor_clear_actions()
is called

Parameters:

Returns:

  • (nil)

#add_action_with_name(name, action) ⇒ nil

A convenience function for setting the name of a Clutter::Action
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:

  • name (String) —

    the name to set on the action

  • action (Clutter::Action) —

    a Clutter::Action

Returns:

  • (nil)

#add_child(child) ⇒ nil

Adds child to the children of self.

This function will acquire a reference on child that will only
be released when calling clutter_actor_remove_child().

This function will take into consideration the Clutter::Actor:depth
of child, and will keep the list of children sorted.

This function will emit the Clutter::Container::actor-added signal
on self.

Parameters:

Returns:

  • (nil)

#add_constraint(constraint) ⇒ nil

Adds constraint to the list of Clutter::Constraints applied
to self

The Clutter::Actor will hold a reference on the constraint until
either clutter_actor_remove_constraint() or
clutter_actor_clear_constraints() is called.

Parameters:

Returns:

  • (nil)

#add_constraint_with_name(name, constraint) ⇒ nil

A convenience function for setting the name of a Clutter::Constraint
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:

  • name (String) —

    the name to set on the constraint

  • constraint (Clutter::Constraint) —

    a Clutter::Constraint

Returns:

  • (nil)

#add_effect(effect) ⇒ nil

Adds effect to the list of Clutter::Effects applied to self

The Clutter::Actor will hold a reference on the effect until either
clutter_actor_remove_effect() or clutter_actor_clear_effects() is
called.

Note that as Clutter::Effect is initially unowned,
clutter_actor_add_effect() will sink any floating reference on effect.

Parameters:

Returns:

  • (nil)

#add_effect_with_name(name, effect) ⇒ nil

A convenience function for setting the name of a Clutter::Effect
while adding it to the list of effects applied to self.

Note that as Clutter::Effect is initially unowned,
clutter_actor_add_effect_with_name() will sink any floating
reference on effect.

This function is the logical equivalent of:

  clutter_actor_meta_set_name (CLUTTER_ACTOR_META (effect), name);
  clutter_actor_add_effect (self, effect);

Parameters:

  • name (String) —

    the name to set on the effect

  • effect (Clutter::Effect) —

    a Clutter::Effect

Returns:

  • (nil)

#add_transition(name, transition) ⇒ nil

Adds a transition to the Clutter::Actor's list of animations.

The name string is a per-actor unique identifier of the transition: only
one Clutter::Transition can be associated to the specified name.

The transition will be started once added.

This function will take a reference on the transition.

This function is usually called implicitly when modifying an animatable
property.

Parameters:

  • name (String) —

    the name of the transition to add

  • transition (Clutter::Transition) —

    the Clutter::Transition to add

Returns:

  • (nil)

#allocate(box, flags) ⇒ nil

Assigns the size of a Clutter::Actor from the given box.

This function should only be called on the children of an actor when
overriding the Clutter::ActorClass.allocate() virtual function.

This function will adjust the stored allocation to take into account
the alignment flags set in the Clutter::Actor:x-align and
Clutter::Actor:y-align properties, as well as the margin values set in
the Clutter::Actor:margin-top, #ClutterActor:margin-right,
Clutter::Actor:margin-bottom, and #ClutterActor:margin-left properties.

This function will respect the easing state of the Clutter::Actor and
interpolate between the current allocation and the new one if the
easing state duration is a positive value.

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:

  • box (Clutter::ActorBox) —

    new allocation of the actor, in parent-relative coordinates

  • flags (Clutter::AllocationFlags) —

    flags that control the allocation

Returns:

  • (nil)

#allocate_align_fill(box, x_align, y_align, x_fill, y_fill, flags) ⇒ nil

Allocates self by taking into consideration the available allocation
area; an alignment factor on either axis; and whether the actor should
fill the allocation on either axis.

The box should contain the available allocation width and height;
if the x1 and y1 members of Clutter::ActorBox are not set to 0, the
allocation will be offset by their value.

This function takes into consideration the geometry request specified by
the Clutter::Actor:request-mode property, and the text direction.

This function is useful for fluid layout managers using legacy alignment
flags. Newly written layout managers should use the Clutter::Actor:x-align
and Clutter::Actor:y-align properties, instead, and just call
clutter_actor_allocate() inside their Clutter::ActorClass.allocate()
implementation.

Parameters:

  • box (Clutter::ActorBox) —

    a Clutter::ActorBox, containing the available width and height

  • x_align (Float) —

    the horizontal alignment, between 0 and 1

  • y_align (Float) —

    the vertical alignment, between 0 and 1

  • x_fill (Boolean) —

    whether the actor should fill horizontally

  • y_fill (Boolean) —

    whether the actor should fill vertically

  • flags (Clutter::AllocationFlags) —

    allocation flags to be passed to clutter_actor_allocate()

Returns:

  • (nil)

#allocate_available_size(x, y, available_width, available_height, flags) ⇒ nil

Allocates self taking into account the Clutter::Actor'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 if (request_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
    {
      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);
    }
  else if (request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
    {
      clutter_content_get_preferred_size (content, &natural_width, &natural_height);

      width = CLAMP (natural_width, 0, available_width);
      height = CLAMP (natural_height, 0, available_height);
    }

  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:

  • x (Clutter::gfloat) —

    the actor's X coordinate

  • y (Clutter::gfloat) —

    the actor's Y coordinate

  • available_width (Clutter::gfloat) —

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

  • available_height (Clutter::gfloat) —

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

  • flags (Clutter::AllocationFlags) —

    flags controlling the allocation

Returns:

  • (nil)

#allocate_preferred_size(flags) ⇒ nil

Allocates the natural size of self.

This function is a utility call for Clutter::Actor implementations
that allocates the actor's preferred natural size. It can be used
by fixed layout managers (like Clutter::Group or so called
'composite actors') inside the ClutterActor::allocate
implementation to give each child exactly how much space it
requires, regardless of the size of the parent.

This function is not meant to be used by applications. It is also
not meant to be used outside the implementation of the
Clutter::ActorClass.allocate virtual function.

Parameters:

Returns:

  • (nil)

#allocation ⇒ Clutter::ActorBox

The allocation for the actor, in pixels

This is property is read-only, but you might monitor it to know when an
actor moves or resizes

Returns:

  • (Clutter::ActorBox) —

    allocation

#allocation=(allocation) ⇒ Clutter::ActorBox

The allocation for the actor, in pixels

This is property is read-only, but you might monitor it to know when an
actor moves or resizes

Parameters:

  • allocation (Clutter::ActorBox)

Returns:

  • (Clutter::ActorBox) —

    allocation

  • (Clutter::ActorBox) —

    allocation

#anchor_gravity ⇒ Clutter::Gravity

The anchor point expressed as a Clutter::Gravity

It is highly recommended not to use Clutter::Actor:anchor-x,
Clutter::Actor:anchor-y, and #ClutterActor:anchor-gravity in newly
written code; the anchor point adds an additional translation that
will affect the actor's relative position with regards to its
parent, as well as the position of its children. This change needs
to always be taken into account when positioning the actor. It is
recommended to use the Clutter::Actor:pivot-point property instead,
as it will affect only the transformations.

Returns:

#anchor_gravity=(anchor_gravity) ⇒ Clutter::Gravity

The anchor point expressed as a Clutter::Gravity

It is highly recommended not to use Clutter::Actor:anchor-x,
Clutter::Actor:anchor-y, and #ClutterActor:anchor-gravity in newly
written code; the anchor point adds an additional translation that
will affect the actor's relative position with regards to its
parent, as well as the position of its children. This change needs
to always be taken into account when positioning the actor. It is
recommended to use the Clutter::Actor:pivot-point property instead,
as it will affect only the transformations.

Parameters:

Returns:

#anchor_point_from_gravity=(gravity) ⇒ nil

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:

Returns:

  • (nil)

#anchor_point_gravity ⇒ Clutter::Gravity

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

Returns:

#anchor_x ⇒ Clutter::gfloat

The X coordinate of an actor's anchor point, relative to
the actor coordinate space, in pixels.

It is highly recommended not to use Clutter::Actor:anchor-x,
Clutter::Actor:anchor-y, and #ClutterActor:anchor-gravity in newly
written code; the anchor point adds an additional translation that
will affect the actor's relative position with regards to its
parent, as well as the position of its children. This change needs
to always be taken into account when positioning the actor. It is
recommended to use the Clutter::Actor:pivot-point property instead,
as it will affect only the transformations.

Returns:

  • (Clutter::gfloat) —

    anchor-x

#anchor_x=(anchor_x) ⇒ Clutter::gfloat

The X coordinate of an actor's anchor point, relative to
the actor coordinate space, in pixels.

It is highly recommended not to use Clutter::Actor:anchor-x,
Clutter::Actor:anchor-y, and #ClutterActor:anchor-gravity in newly
written code; the anchor point adds an additional translation that
will affect the actor's relative position with regards to its
parent, as well as the position of its children. This change needs
to always be taken into account when positioning the actor. It is
recommended to use the Clutter::Actor:pivot-point property instead,
as it will affect only the transformations.

Parameters:

  • anchor_x (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    anchor-x

  • (Clutter::gfloat) —

    anchor-x

#anchor_y ⇒ Clutter::gfloat

The Y coordinate of an actor's anchor point, relative to
the actor coordinate space, in pixels

It is highly recommended not to use Clutter::Actor:anchor-x,
Clutter::Actor:anchor-y, and #ClutterActor:anchor-gravity in newly
written code; the anchor point adds an additional translation that
will affect the actor's relative position with regards to its
parent, as well as the position of its children. This change needs
to always be taken into account when positioning the actor. It is
recommended to use the Clutter::Actor:pivot-point property instead,
as it will affect only the transformations.

Returns:

  • (Clutter::gfloat) —

    anchor-y

#anchor_y=(anchor_y) ⇒ Clutter::gfloat

The Y coordinate of an actor's anchor point, relative to
the actor coordinate space, in pixels

It is highly recommended not to use Clutter::Actor:anchor-x,
Clutter::Actor:anchor-y, and #ClutterActor:anchor-gravity in newly
written code; the anchor point adds an additional translation that
will affect the actor's relative position with regards to its
parent, as well as the position of its children. This change needs
to always be taken into account when positioning the actor. It is
recommended to use the Clutter::Actor:pivot-point property instead,
as it will affect only the transformations.

Parameters:

  • anchor_y (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    anchor-y

  • (Clutter::gfloat) —

    anchor-y

#animate(mode, duration, first_property_name, array) ⇒ Clutter::Animation

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.

For example, this:

  static void
  on_animation_completed (ClutterAnimation *animation,
                          ClutterActor     *actor)
  {
    clutter_actor_animate (actor, CLUTTER_EASE_OUT_CUBIC, 250,
                           "x", 500.0,
                           "y", 500.0,
                           NULL);
  }

    ...
    animation = clutter_actor_animate (actor, CLUTTER_EASE_IN_CUBIC, 250,
                                       "x", 100.0,
                                       "y", 100.0,
                                       NULL);
    g_signal_connect (animation, "completed",
                      G_CALLBACK (on_animation_completed),
                      actor);
    ...

Parameters:

  • mode (Clutter::gulong) —

    an animation mode logical id

  • duration (Integer) —

    duration of the animation, in milliseconds

  • first_property_name (String) —

    the name of a property

  • array (Array) —

    a nil terminated list of property names and
    property values

Returns:

  • (Clutter::Animation) —

    a Clutter::Animation object. The object is
    owned by the Clutter::Actor and should not be unreferenced with
    g_object_unref()

#animate_with_alpha(alpha, first_property_name, array) ⇒ Clutter::Animation

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 Clutter::Alpha
to animate actor.

Parameters:

  • alpha (Clutter::Alpha) —

    a Clutter::Alpha

  • first_property_name (String) —

    the name of a property

  • array (Array) —

    a nil terminated list of property names and
    property values

Returns:

  • (Clutter::Animation) —

    a Clutter::Animation object. The object is owned by the
    Clutter::Actor and should not be unreferenced with g_object_unref()

#animate_with_alphav(alpha, n_properties, properties, values) ⇒ Clutter::Animation

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 Clutter::Alpha
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.

Parameters:

  • alpha (Clutter::Alpha) —

    a Clutter::Alpha

  • n_properties (Integer) —

    number of property names and values

  • properties (Array<String>) —

    a vector
    containing the property names to set

  • values (Array<GObject::Value>) —

    a vector containing the
    property values to set

Returns:

  • (Clutter::Animation) —

    a Clutter::Animation object. The object is owned by the
    Clutter::Actor and should not be unreferenced with g_object_unref()

#animate_with_timeline(mode, timeline, first_property_name, array) ⇒ Clutter::Animation

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.

Parameters:

  • mode (Clutter::gulong) —

    an animation mode logical id

  • timeline (Clutter::Timeline) —

    a Clutter::Timeline

  • first_property_name (String) —

    the name of a property

  • array (Array) —

    a nil terminated list of property names and
    property values

Returns:

  • (Clutter::Animation) —

    a Clutter::Animation object. The object is
    owned by the Clutter::Actor and should not be unreferenced with
    g_object_unref()

#animate_with_timelinev(mode, timeline, n_properties, properties, values) ⇒ Clutter::Animation

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.

Parameters:

  • mode (Clutter::gulong) —

    an animation mode logical id

  • timeline (Clutter::Timeline) —

    a Clutter::Timeline

  • n_properties (Integer) —

    number of property names and values

  • properties (Array<String>) —

    a vector
    containing the property names to set

  • values (Array<GObject::Value>) —

    a vector containing the
    property values to set

Returns:

  • (Clutter::Animation) —

    a Clutter::Animation object. The object is
    owned by the Clutter::Actor and should not be unreferenced with
    g_object_unref()

#animatev(mode, duration, n_properties, properties, values) ⇒ Clutter::Animation

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.

Parameters:

  • mode (Clutter::gulong) —

    an animation mode logical id

  • duration (Integer) —

    duration of the animation, in milliseconds

  • n_properties (Integer) —

    number of property names and values

  • properties (Array<String>) —

    a vector
    containing the property names to set

  • values (Array<GObject::Value>) —

    a vector containing the
    property values to set

Returns:

  • (Clutter::Animation) —

    a Clutter::Animation object. The object is
    owned by the Clutter::Actor and should not be unreferenced with
    g_object_unref()

#animation ⇒ Clutter::Animation

Retrieves the Clutter::Animation used by actor, if clutter_actor_animate()
has been called on actor.

Returns:

#apply_relative_transform_to_point(ancestor, point, vertex) ⇒ nil

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 nil the ancestor will be the Clutter::Stage. 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:

  • ancestor (Clutter::Actor) —

    A Clutter::Actor ancestor, or nil to use the
    default Clutter::Stage

  • point (Clutter::Vertex) —

    A point as Clutter::Vertex

  • vertex (Clutter::Vertex) —

    The translated Clutter::Vertex

Returns:

  • (nil)

#apply_transform_to_point(point, vertex) ⇒ nil

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

Parameters:

  • point (Clutter::Vertex) —

    A point as Clutter::Vertex

  • vertex (Clutter::Vertex) —

    The translated Clutter::Vertex

Returns:

  • (nil)

#background_color ⇒ Clutter::Color

Paints a solid fill of the actor's allocation using the specified
color.

The Clutter::Actor:background-color property is animatable.

Returns:

#background_color=(background_color) ⇒ Clutter::Color

Paints a solid fill of the actor's allocation using the specified
color.

The Clutter::Actor:background-color property is animatable.

Parameters:

Returns:

#background_color_set=(background_color_set) ⇒ Boolean

Whether the Clutter::Actor:background-color property has been set.

Parameters:

  • background_color_set (Boolean)

Returns:

  • (Boolean) —

    background-color-set

  • (Boolean) —

    background-color-set

#background_color_set? ⇒ Boolean

Whether the Clutter::Actor:background-color property has been set.

Returns:

  • (Boolean) —

    background-color-set

#bind_model(model, create_child_func, user_data, notify) ⇒ nil

Binds a GList::Model to a #ClutterActor.

If the Clutter::Actor was already bound to a #GListModel, the previous
binding is destroyed.

The existing children of Clutter::Actor are destroyed when setting a
model, and new children are created and added, representing the contents
of the model. The Clutter::Actor is updated whenever the model changes.
If model is nil, the Clutter::Actor is left empty.

When a Clutter::Actor is bound to a model, adding and removing children
directly is undefined behaviour.

Parameters:

  • model (Gio::ListModel) —

    a GList::Model

  • create_child_func (Clutter::ActorCreateChildFunc) —

    a function that creates Clutter::Actor instances
    from the contents of the model

  • user_data (GObject) —

    user data passed to create_child_func

  • notify (GLib::DestroyNotify) —

    function called when unsetting the model

Returns:

  • (nil)

#bind_model_with_properties(model, child_type, first_model_property, array) ⇒ nil

Binds a GList::Model to a #ClutterActor.

Unlike clutter_actor_bind_model(), this function automatically creates
a child Clutter::Actor of type child_type, and binds properties on the
items inside the model to the corresponding properties on the child,
for instance:

  ClutterActor *res = g_object_new (MY_TYPE_CHILD_VIEW, NULL);

  g_object_bind_property (item, "label", res, "text", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
  g_object_bind_property (item, "icon", res, "image", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
  g_object_bind_property (item, "selected", res, "selected", G_BINDING_BIDIRECTIONAL);
  g_object_bind_property (item, "active", res, "active", G_BINDING_BIDIRECTIONAL);

  return res;

If the Clutter::Actor was already bound to a #GListModel, the previous
binding is destroyed.

When a Clutter::Actor is bound to a model, adding and removing children
directly is undefined behaviour.

See also: clutter_actor_bind_model()

Parameters:

  • model (Gio::ListModel) —

    a GList::Model

  • child_type (GLib::Type) —

    the type of Clutter::Actor to use when creating
    children mapping to items inside the model

  • first_model_property (String) —

    the first property of model to bind

  • array (Array) —

    tuples of property names on the model, on the child, and the
    GBinding::Flags used to bind them, terminated by nil

Returns:

  • (nil)

#child_transform ⇒ Clutter::Matrix

Applies a transformation matrix on each child of an actor.

Setting this property with a Clutter::Matrix will set the
Clutter::Actor:child-transform-set property to true as a side effect;
setting this property with nil will set the
Clutter::Actor:child-transform-set property to false.

The Clutter::Actor:child-transform property is animatable.

Returns:

  • (Clutter::Matrix) —

    child-transform

#child_transform=(child_transform) ⇒ Clutter::Matrix

Applies a transformation matrix on each child of an actor.

Setting this property with a Clutter::Matrix will set the
Clutter::Actor:child-transform-set property to true as a side effect;
setting this property with nil will set the
Clutter::Actor:child-transform-set property to false.

The Clutter::Actor:child-transform property is animatable.

Parameters:

  • child_transform (Clutter::Matrix)

Returns:

  • (Clutter::Matrix) —

    child-transform

  • (Clutter::Matrix) —

    child-transform

#child_transform_set=(child_transform_set) ⇒ Boolean

Whether the Clutter::Actor:child-transform property is set.

Parameters:

  • child_transform_set (Boolean)

Returns:

  • (Boolean) —

    child-transform-set

  • (Boolean) —

    child-transform-set

#child_transform_set? ⇒ Boolean

Whether the Clutter::Actor:child-transform property is set.

Returns:

  • (Boolean) —

    child-transform-set

#children ⇒ GLib::List<Clutter::Actor>

Retrieves the list of children of self.

Returns:

  • (GLib::List<Clutter::Actor>) —

    A newly
    allocated #GList of Clutter::Actors. Use g_list_free() when
    done.

#clear_actions ⇒ nil

Clears the list of actions applied to self

Returns:

  • (nil)

#clear_constraints ⇒ nil

Clears the list of constraints applied to self

Returns:

  • (nil)

#clear_effects ⇒ nil

Clears the list of effects applied to self

Returns:

  • (nil)

#clip ⇒ Clutter::Geometry

The visible region of the actor, in actor-relative coordinates

Returns:

  • (Clutter::Geometry) —

    clip

#clip=(clip) ⇒ Clutter::Geometry

The visible region of the actor, in actor-relative coordinates

Parameters:

  • clip (Clutter::Geometry)

Returns:

  • (Clutter::Geometry) —

    clip

  • (Clutter::Geometry) —

    clip

#clip_rect ⇒ Clutter::Rect

The visible region of the actor, in actor-relative coordinates,
expressed as a Clutter::Rect.

Setting this property to nil will unset the existing clip.

Setting this property will change the Clutter::Actor:has-clip
property as a side effect.

Returns:

  • (Clutter::Rect) —

    clip-rect

#clip_rect=(clip_rect) ⇒ Clutter::Rect

The visible region of the actor, in actor-relative coordinates,
expressed as a Clutter::Rect.

Setting this property to nil will unset the existing clip.

Setting this property will change the Clutter::Actor:has-clip
property as a side effect.

Parameters:

  • clip_rect (Clutter::Rect)

Returns:

  • (Clutter::Rect) —

    clip-rect

  • (Clutter::Rect) —

    clip-rect

#clip_to_allocation ⇒ Boolean

Retrieves the value set using clutter_actor_set_clip_to_allocation()

Returns:

  • (Boolean) —

    true if the Clutter::Actor is clipped to its allocation

#clip_to_allocation=(clip_to_allocation) ⇒ Boolean

Whether the clip region should track the allocated area
of the actor.

This property is ignored if a clip area has been explicitly
set using clutter_actor_set_clip().

Parameters:

  • clip_to_allocation (Boolean)

Returns:

  • (Boolean) —

    clip-to-allocation

  • (Boolean) —

    clip-to-allocation

#clip_to_allocation? ⇒ Boolean

Whether the clip region should track the allocated area
of the actor.

This property is ignored if a clip area has been explicitly
set using clutter_actor_set_clip().

Returns:

  • (Boolean) —

    clip-to-allocation

#constraints ⇒ GLib::List<Clutter::Constraint>

Retrieves the list of constraints applied to self

Returns:

  • (GLib::List<Clutter::Constraint>) —

    a copy
    of the list of Clutter::Constraints. The contents of the list are
    owned by the Clutter::Actor. Use g_list_free() to free the resources
    allocated by the returned #GList

#constraints=(constraints) ⇒ Clutter::Constraint

Adds a Clutter::Constraint to the actor

Parameters:

Returns:

#contains(descendant) ⇒ Boolean

Determines if descendant is contained inside self (either as an
immediate child, or as a deeper descendant). If self and
descendant point to the same actor then it will also return true.

Parameters:

  • descendant (Clutter::Actor) —

    A Clutter::Actor, possibly contained in self

Returns:

  • (Boolean) —

    whether descendent is contained within self

#content ⇒ Clutter::Content

The Clutter::Content implementation that controls the content
of the actor.

Returns:

#content=(content) ⇒ Clutter::Content

The Clutter::Content implementation that controls the content
of the actor.

Parameters:

Returns:

#content_box ⇒ Clutter::ActorBox

The bounding box for the Clutter::Content used by the actor.

The value of this property is controlled by the Clutter::Actor:allocation
and Clutter::Actor:content-gravity properties of #ClutterActor.

The bounding box for the content is guaranteed to never exceed the
allocation's of the actor.

Returns:

  • (Clutter::ActorBox) —

    content-box

#content_box=(content_box) ⇒ Clutter::ActorBox

The bounding box for the Clutter::Content used by the actor.

The value of this property is controlled by the Clutter::Actor:allocation
and Clutter::Actor:content-gravity properties of #ClutterActor.

The bounding box for the content is guaranteed to never exceed the
allocation's of the actor.

Parameters:

  • content_box (Clutter::ActorBox)

Returns:

  • (Clutter::ActorBox) —

    content-box

  • (Clutter::ActorBox) —

    content-box

#content_gravity ⇒ Clutter::ContentGravity

The alignment that should be honoured by the Clutter::Content
set with the Clutter::Actor:content property.

Changing the value of this property will change the bounding box of
the content; you can use the Clutter::Actor:content-box property to
get the position and size of the content within the actor's
allocation.

This property is meaningful only for Clutter::Content implementations
that have a preferred size, and if the preferred size is smaller than
the actor's allocation.

The Clutter::Actor:content-gravity property is animatable.

Returns:

#content_gravity=(content_gravity) ⇒ Clutter::ContentGravity

The alignment that should be honoured by the Clutter::Content
set with the Clutter::Actor:content property.

Changing the value of this property will change the bounding box of
the content; you can use the Clutter::Actor:content-box property to
get the position and size of the content within the actor's
allocation.

This property is meaningful only for Clutter::Content implementations
that have a preferred size, and if the preferred size is smaller than
the actor's allocation.

The Clutter::Actor:content-gravity property is animatable.

Parameters:

Returns:

#content_repeat ⇒ Clutter::ContentRepeat

The repeat policy for the actor's Clutter::Actor:content.

Returns:

#content_repeat=(content_repeat) ⇒ Clutter::ContentRepeat

The repeat policy for the actor's Clutter::Actor:content.

Parameters:

Returns:

#continue_paint ⇒ nil

Run the next stage of the paint sequence. This function should only
be called within the implementation of the ‘run’ virtual of a
Clutter::Effect. It will cause the run method of the next effect to
be applied, or it will paint the actual actor if the current effect
is the last effect in the chain.

Returns:

  • (nil)

#create_pango_context ⇒ Pango::Context

Creates a Pango::Context 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().

Returns:

  • (Pango::Context) —

    the newly created Pango::Context.
    Use g_object_unref() on the returned value to deallocate its
    resources

#create_pango_layout(text) ⇒ Pango::Layout

Creates a new Pango::Layout from the same #PangoContext used
by the Clutter::Actor. The #PangoLayout is already configured
with the font map, resolution and font options, and the
given text.

If you want to keep around a Pango::Layout created by this
function you will have to connect to the Clutter::Backend::font-changed
and Clutter::Backend::resolution-changed signals, and call
pango_layout_context_changed() in response to them.

Parameters:

  • text (String) —

    the text to set on the Pango::Layout, or nil

Returns:

  • (Pango::Layout) —

    the newly created Pango::Layout.
    Use g_object_unref() when done

#default_paint_volume ⇒ Clutter::PaintVolume

Retrieves the default paint volume for self.

This function provides the same Clutter::PaintVolume that would be
computed by the default implementation inside Clutter::Actor of the
Clutter::ActorClass.get_paint_volume() virtual function.

This function should only be used by Clutter::Actor subclasses that
cannot chain up to the parent implementation when computing their
paint volume.

Returns:

  • (Clutter::PaintVolume) —

    a pointer to the default
    Clutter::PaintVolume, relative to the #ClutterActor, or nil if
    the actor could not compute a valid paint volume. The returned value
    is not guaranteed to be stable across multiple frames, so if you
    want to retain it, you will need to copy it using
    clutter_paint_volume_copy().

#depth ⇒ Clutter::gfloat

The position of the actor on the Z axis.

The Clutter::Actor:depth property is relative to the parent's
modelview matrix.

Setting this property will call Clutter::ContainerIface.sort_depth_order()
which is usually a no-op, and it's most likely not what you want.

The Clutter::Actor:depth property is animatable.

Returns:

  • (Clutter::gfloat) —

    depth

#depth=(depth) ⇒ Clutter::gfloat

The position of the actor on the Z axis.

The Clutter::Actor:depth property is relative to the parent's
modelview matrix.

Setting this property will call Clutter::ContainerIface.sort_depth_order()
which is usually a no-op, and it's most likely not what you want.

The Clutter::Actor:depth property is animatable.

Parameters:

  • depth (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    depth

  • (Clutter::gfloat) —

    depth

#destroy ⇒ nil

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.

Note: you cannot destroy the Clutter::Stage returned by
clutter_stage_get_default().

Returns:

  • (nil)

#destroy_all_children ⇒ nil

Destroys all children of self.

This function releases the reference added by inserting a child
actor in the list of children of self, and ensures that the
Clutter::Actor::destroy signal is emitted on each child of the
actor.

By default, Clutter::Actor will emit the #ClutterActor::destroy signal
when its reference count drops to 0; the default handler of the
Clutter::Actor::destroy signal will destroy all the children of an
actor. This function ensures that all children are destroyed, instead
of just removed from self, unlike clutter_actor_remove_all_children()
which will merely release the reference and remove each child.

Unless you acquired an additional reference on each child of self
prior to calling clutter_actor_remove_all_children() and want to reuse
the actors, you should use clutter_actor_destroy_all_children() in
order to make sure that children are destroyed and signal handlers
are disconnected even in cases where circular references prevent this
from automatically happening through reference counting alone.

Returns:

  • (nil)

#detach_animation ⇒ nil

Detaches the Clutter::Animation used by actor, if clutter_actor_animate()
has been called on actor.

Once the animation has been detached, it loses a reference. If it was
the only reference then the Clutter::Animation becomes invalid.

The Clutter::Animation::completed signal will not be emitted.

Returns:

  • (nil)

#easing_delay ⇒ Integer

Retrieves the delay that should be applied when tweening animatable
properties.

Returns:

  • (Integer) —

    a delay, in milliseconds

#easing_delay=(msecs) ⇒ nil

Sets the delay that should be applied before tweening animatable
properties.

Parameters:

  • msecs (Integer) —

    the delay before the start of the tweening, in milliseconds

Returns:

  • (nil)

#easing_duration ⇒ Integer

Retrieves the duration of the tweening for animatable
properties of self for the current easing state.

Returns:

  • (Integer) —

    the duration of the tweening, in milliseconds

#easing_duration=(msecs) ⇒ nil

Sets the duration of the tweening for animatable properties
of self for the current easing state.

Parameters:

  • msecs (Integer) —

    the duration of the easing, or nil

Returns:

  • (nil)

#easing_mode ⇒ Clutter::AnimationMode

Retrieves the easing mode for the tweening of animatable properties
of self for the current easing state.

Returns:

#easing_mode=(mode) ⇒ nil

Sets the easing mode for the tweening of animatable properties
of self.

Parameters:

Returns:

  • (nil)

#effect=(effect) ⇒ Clutter::Effect

Adds Clutter::Effect to the list of effects be applied on a #ClutterActor

Parameters:

Returns:

#effects ⇒ GLib::List<Clutter::Effect>

Retrieves the Clutter::Effects applied on self, if any

Returns:

  • (GLib::List<Clutter::Effect>) —

    a list
    of Clutter::Effects, or nil. 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

#event(event, capture) ⇒ Boolean

This function is used to emit an event on the main stage.
You should rarely need to use this function, except for
synthetising events.

Parameters:

  • event (Clutter::Event) —

    a Clutter::Event

  • capture (Boolean) —

    true if event in in capture phase, false otherwise.

Returns:

  • (Boolean) —

    the return value from the signal emission: true
    if the actor handled the event, or false if the event was
    not handled

#first_child ⇒ Clutter::Actor

The actor's first child.

Returns:

#first_child=(first_child) ⇒ Clutter::Actor

The actor's first child.

Parameters:

Returns:

#fixed_position_set ⇒ Boolean

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

Returns:

  • (Boolean) —

    true if the fixed position is set on the actor

#fixed_position_set=(fixed_position_set) ⇒ Boolean

This flag controls whether the Clutter::Actor:fixed-x and
Clutter::Actor:fixed-y properties are used

Parameters:

  • fixed_position_set (Boolean)

Returns:

  • (Boolean) —

    fixed-position-set

  • (Boolean) —

    fixed-position-set

#fixed_position_set? ⇒ Boolean

This flag controls whether the Clutter::Actor:fixed-x and
Clutter::Actor:fixed-y properties are used

Returns:

  • (Boolean) —

    fixed-position-set

#fixed_x ⇒ Clutter::gfloat

The fixed X position of the actor in pixels.

Writing this property sets Clutter::Actor:fixed-position-set
property as well, as a side effect

Returns:

  • (Clutter::gfloat) —

    fixed-x

#fixed_x=(fixed_x) ⇒ Clutter::gfloat

The fixed X position of the actor in pixels.

Writing this property sets Clutter::Actor:fixed-position-set
property as well, as a side effect

Parameters:

  • fixed_x (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    fixed-x

  • (Clutter::gfloat) —

    fixed-x

#fixed_y ⇒ Clutter::gfloat

The fixed Y position of the actor in pixels.

Writing this property sets the Clutter::Actor:fixed-position-set
property as well, as a side effect

Returns:

  • (Clutter::gfloat) —

    fixed-y

#fixed_y=(fixed_y) ⇒ Clutter::gfloat

The fixed Y position of the actor in pixels.

Writing this property sets the Clutter::Actor:fixed-position-set
property as well, as a side effect

Parameters:

  • fixed_y (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    fixed-y

  • (Clutter::gfloat) —

    fixed-y

#flags ⇒ Clutter::ActorFlags

Retrieves the flags set on self

Returns:

#flags=(flags) ⇒ nil

Sets flags on self

This function will emit notifications for the changed properties

Parameters:

Returns:

  • (nil)

#geometry=(geometry) ⇒ nil

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:

  • geometry (Clutter::Geometry) —

    A Clutter::Geometry

Returns:

  • (nil)

#get_abs_allocation_vertices(verts) ⇒ nil

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

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

Parameters:

  • verts (Array<Clutter::Vertex>) —

    Pointer to a location of an array
    of 4 Clutter::Vertex where to store the result.

Returns:

  • (nil)

#get_action(name) ⇒ Clutter::Action

Retrieves the Clutter::Action with the given name in the list
of actions applied to self

Parameters:

  • name (String) —

    the name of the action to retrieve

Returns:

  • (Clutter::Action) —

    a Clutter::Action for the given
    name, or nil. The returned Clutter::Action is owned by the
    actor and it should not be unreferenced directly

#get_allocation_box(box) ⇒ nil

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.

Parameters:

  • box (Clutter::ActorBox) —

    the function fills this in with the actor's allocation

Returns:

  • (nil)

#get_allocation_geometry(geom) ⇒ nil

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.

Parameters:

  • geom (Clutter::Geometry) —

    allocation geometry in pixels

Returns:

  • (nil)

#get_allocation_vertices(ancestor, verts) ⇒ nil

Calculates the transformed coordinates of the four corners of the
actor in the plane of ancestor. The returned vertices relate to
the Clutter::ActorBox 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 nil the ancestor will be the Clutter::Stage. 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:

  • ancestor (Clutter::Actor) —

    A Clutter::Actor to calculate the vertices
    against, or nil to use the Clutter::Stage

  • verts (Array<Clutter::Vertex>) —

    return
    location for an array of 4 Clutter::Vertex in which to store the result

Returns:

  • (nil)

#get_anchor_point(anchor_x, anchor_y) ⇒ nil

Gets the current anchor point of the actor in pixels.

Parameters:

  • anchor_x (Clutter::gfloat) —

    return location for the X coordinate of the anchor point

  • anchor_y (Clutter::gfloat) —

    return location for the Y coordinate of the anchor point

Returns:

  • (nil)

#get_background_color(color) ⇒ nil

Retrieves the color set using clutter_actor_set_background_color().

Parameters:

Returns:

  • (nil)

#get_child_at_index(index_) ⇒ Clutter::Actor

Retrieves the actor at the given index_ inside the list of
children of self.

Parameters:

  • index_ (Integer) —

    the position in the list of children

Returns:

#get_child_transform(transform) ⇒ nil

Retrieves the child transformation matrix set using
clutter_actor_set_child_transform(); if none is currently set,
the transform matrix will be initialized to the identity matrix.

Parameters:

  • transform (Clutter::Matrix) —

    a Clutter::Matrix

Returns:

  • (nil)

#get_clip(xoff, yoff, width, height) ⇒ nil

Gets the clip area for self, if any is set.

Parameters:

  • xoff (Clutter::gfloat) —

    return location for the X offset of
    the clip rectangle, or nil

  • yoff (Clutter::gfloat) —

    return location for the Y offset of
    the clip rectangle, or nil

  • width (Clutter::gfloat) —

    return location for the width of
    the clip rectangle, or nil

  • height (Clutter::gfloat) —

    return location for the height of
    the clip rectangle, or nil

Returns:

  • (nil)

#get_constraint(name) ⇒ Clutter::Constraint

Retrieves the Clutter::Constraint with the given name in the list
of constraints applied to self

Parameters:

  • name (String) —

    the name of the constraint to retrieve

Returns:

  • (Clutter::Constraint) —

    a Clutter::Constraint for the given
    name, or nil. The returned Clutter::Constraint is owned by the
    actor and it should not be unreferenced directly

#get_content_box(box) ⇒ nil

Retrieves the bounding box for the Clutter::Content of self.

The bounding box is relative to the actor's allocation.

If no Clutter::Content is set for self, or if self has not been
allocated yet, then the result is undefined.

The content box is guaranteed to be, at most, as big as the allocation
of the Clutter::Actor.

If the Clutter::Content used by the actor has a preferred size, then
it is possible to modify the content box by using the
Clutter::Actor:content-gravity property.

Parameters:

  • box (Clutter::ActorBox) —

    the return location for the bounding
    box for the Clutter::Content

Returns:

  • (nil)

#get_content_scaling_filters(min_filter, mag_filter) ⇒ nil

Retrieves the values set using clutter_actor_set_content_scaling_filters().

Parameters:

Returns:

  • (nil)

#get_effect(name) ⇒ Clutter::Effect

Retrieves the Clutter::Effect with the given name in the list
of effects applied to self

Parameters:

  • name (String) —

    the name of the effect to retrieve

Returns:

  • (Clutter::Effect) —

    a Clutter::Effect for the given
    name, or nil. The returned Clutter::Effect is owned by the
    actor and it should not be unreferenced directly

#get_geometry(geometry) ⇒ nil

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.

Parameters:

  • geometry (Clutter::Geometry) —

    A location to store actors Clutter::Geometry

Returns:

  • (nil)

#get_margin(margin) ⇒ nil

Retrieves all the components of the margin of a Clutter::Actor.

Parameters:

  • margin (Clutter::Margin) —

    return location for a Clutter::Margin

Returns:

  • (nil)

#get_paint_box(box) ⇒ Boolean

Retrieves the paint volume of the passed Clutter::Actor, and
transforms it into a 2D bounding box in stage coordinates.

This function is useful to determine the on screen area occupied by
the actor. The box is only an approximation and may often be
considerably larger due to the optimizations used to calculate the
box. The box is never smaller though, so it can reliably be used
for culling.

There are times when a 2D paint box can't be determined, e.g.
because the actor isn't yet parented under a stage or because
the actor is unable to determine a paint volume.
false.

Parameters:

  • box (Clutter::ActorBox) —

    return location for a Clutter::ActorBox

Returns:

  • (Boolean) —

    true if a 2D paint box could be determined, else

#get_pivot_point(pivot_x, pivot_y) ⇒ nil

Retrieves the coordinates of the Clutter::Actor:pivot-point.

Parameters:

  • pivot_x (Clutter::gfloat) —

    return location for the normalized X
    coordinate of the pivot point, or nil

  • pivot_y (Clutter::gfloat) —

    return location for the normalized Y
    coordinate of the pivot point, or nil

Returns:

  • (nil)

#get_position(x, y) ⇒ nil

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.

Parameters:

  • x (Clutter::gfloat) —

    return location for the X coordinate, or nil

  • y (Clutter::gfloat) —

    return location for the Y coordinate, or nil

Returns:

  • (nil)

#get_preferred_height(for_width, min_height_p, natural_height_p) ⇒ nil

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:

  • for_width (Clutter::gfloat) —

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

  • min_height_p (Clutter::gfloat) —

    return location for minimum height,
    or nil

  • natural_height_p (Clutter::gfloat) —

    return location for natural
    height, or nil

Returns:

  • (nil)

#get_preferred_size(min_width_p, min_height_p, natural_width_p, natural_height_p) ⇒ nil

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 Clutter::Actor:request-mode property.

Parameters:

  • min_width_p (Clutter::gfloat) —

    return location for the minimum
    width, or nil

  • min_height_p (Clutter::gfloat) —

    return location for the minimum
    height, or nil

  • natural_width_p (Clutter::gfloat) —

    return location for the natural
    width, or nil

  • natural_height_p (Clutter::gfloat) —

    return location for the natural
    height, or nil

Returns:

  • (nil)

#get_preferred_width(for_height, min_width_p, natural_width_p) ⇒ nil

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:

  • for_height (Clutter::gfloat) —

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

  • min_width_p (Clutter::gfloat) —

    return location for minimum width,
    or nil

  • natural_width_p (Clutter::gfloat) —

    return location for the natural
    width, or nil

Returns:

  • (nil)

#get_rotation(axis, x, y, z) ⇒ Float

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

Parameters:

  • axis (Clutter::RotateAxis) —

    the axis of rotation

  • x (Clutter::gfloat) —

    return value for the X coordinate of the center of rotation

  • y (Clutter::gfloat) —

    return value for the Y coordinate of the center of rotation

  • z (Clutter::gfloat) —

    return value for the Z coordinate of the center of rotation

Returns:

  • (Float) —

    the angle of rotation

#get_rotation_angle(axis) ⇒ Float

Retrieves the angle of rotation set by clutter_actor_set_rotation_angle().

Parameters:

Returns:

  • (Float) —

    the angle of rotation, in degrees

#get_scale(scale_x, scale_y) ⇒ nil

Retrieves an actors scale factors.

Parameters:

  • scale_x (Float) —

    Location to store horizonal
    scale factor, or nil.

  • scale_y (Float) —

    Location to store vertical
    scale factor, or nil.

Returns:

  • (nil)

#get_scale_center(center_x, center_y) ⇒ nil

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

Parameters:

  • center_x (Clutter::gfloat) —

    Location to store the X position
    of the scale center, or nil.

  • center_y (Clutter::gfloat) —

    Location to store the Y position
    of the scale center, or nil.

Returns:

  • (nil)

#get_size(width, height) ⇒ nil

This function tries to "do what you mean" and return
the size an actor will have. If the actor has a valid
allocation, the allocation will be returned; otherwise,
the actors natural size request will be returned.

If you care whether you get the request vs. the allocation, you
should probably call a different function like
clutter_actor_get_allocation_box() or
clutter_actor_get_preferred_width().

Parameters:

  • width (Clutter::gfloat) —

    return location for the width, or nil.

  • height (Clutter::gfloat) —

    return location for the height, or nil.

Returns:

  • (nil)

#get_transform(transform) ⇒ nil

Retrieves the current transformation matrix of a Clutter::Actor.

Parameters:

  • transform (Clutter::Matrix) —

    a Clutter::Matrix

Returns:

  • (nil)

#get_transformation_matrix(matrix) ⇒ nil

Retrieves the transformations applied to self relative to its
parent.

Parameters:

  • matrix (Clutter::Matrix) —

    the return location for a Clutter::Matrix

Returns:

  • (nil)

#get_transformed_paint_volume(relative_to_ancestor) ⇒ Clutter::PaintVolume

Retrieves the 3D paint volume of an actor like
clutter_actor_get_paint_volume() does (Please refer to the
documentation of clutter_actor_get_paint_volume() for more
details.) and it additionally transforms the paint volume into the
coordinate space of relative_to_ancestor. (Or the stage if nil
is passed for relative_to_ancestor)

This can be used by containers that base their paint volume on
the volume of their children. Such containers can query the
transformed paint volume of all of its children and union them
together using clutter_paint_volume_union().

Parameters:

  • relative_to_ancestor (Clutter::Actor) —

    A Clutter::Actor that is an ancestor of self
    (or nil for the stage)

Returns:

  • (Clutter::PaintVolume) —

    a pointer to a Clutter::PaintVolume,
    or nil if no volume could be determined. The returned pointer is
    not guaranteed to be valid across multiple frames; if you wish to
    keep it, you will have to copy it using clutter_paint_volume_copy().

#get_transformed_position(x, y) ⇒ nil

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

Parameters:

  • x (Clutter::gfloat) —

    return location for the X coordinate, or nil

  • y (Clutter::gfloat) —

    return location for the Y coordinate, or nil

Returns:

  • (nil)

#get_transformed_size(width, height) ⇒ nil

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.

Parameters:

  • width (Clutter::gfloat) —

    return location for the width, or nil

  • height (Clutter::gfloat) —

    return location for the height, or nil

Returns:

  • (nil)

#get_transition(name) ⇒ Clutter::Transition

Retrieves the Clutter::Transition of a #ClutterActor by using the
transition name.

Transitions created for animatable properties use the name of the
property itself, for instance the code below:

  clutter_actor_set_easing_duration (actor, 1000);
  clutter_actor_set_rotation (actor, CLUTTER_Y_AXIS, 360.0, x, y, z);

  transition = clutter_actor_get_transition (actor, "rotation-angle-y");
  g_signal_connect (transition, "stopped",
                    G_CALLBACK (on_transition_stopped),
                    actor);

will call the on_transition_stopped callback when the transition
is finished.

If you just want to get notifications of the completion of a transition,
you should use the Clutter::Actor::transition-stopped signal, using the
transition name as the signal detail.

Parameters:

  • name (String) —

    the name of the transition

Returns:

  • (Clutter::Transition) —

    a Clutter::Transition, or nil is none
    was found to match the passed name; the returned instance is owned
    by Clutter and it should not be freed

#get_translation(translate_x, translate_y, translate_z) ⇒ nil

Retrieves the translation set using clutter_actor_set_translation().

Parameters:

  • translate_x (Clutter::gfloat) —

    return location for the X component
    of the translation, or nil

  • translate_y (Clutter::gfloat) —

    return location for the Y component
    of the translation, or nil

  • translate_z (Clutter::gfloat) —

    return location for the Z component
    of the translation, or nil

Returns:

  • (nil)

#gid ⇒ Integer

Retrieves the unique id for self.

Returns:

  • (Integer) —

    Globally unique value for this object instance.

#grab_key_focus ⇒ nil

Sets the key focus of the Clutter::Stage including self
to this Clutter::Actor.

Returns:

  • (nil)

#has_actions ⇒ Boolean

Returns whether the actor has any actions applied.

Returns:

  • (Boolean) —

    true if the actor has any actions,
    false otherwise

#has_allocation ⇒ Boolean

Checks if the actor has an up-to-date allocation assigned to
it. This means that the actor should have an allocation: it's
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:

  • (Boolean) —

    true if the actor has an up-to-date allocation

#has_clip ⇒ Boolean

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

Returns:

  • (Boolean) —

    true if the actor has a clip area set.

#has_clip=(has_clip) ⇒ Boolean

Whether the actor has the Clutter::Actor:clip property set or not

Parameters:

  • has_clip (Boolean)

Returns:

  • (Boolean) —

    has-clip

  • (Boolean) —

    has-clip

#has_clip? ⇒ Boolean

Whether the actor has the Clutter::Actor:clip property set or not

Returns:

  • (Boolean) —

    has-clip

#has_constraints ⇒ Boolean

Returns whether the actor has any constraints applied.

Returns:

  • (Boolean) —

    true if the actor has any constraints,
    false otherwise

#has_effects ⇒ Boolean

Returns whether the actor has any effects applied.

Returns:

  • (Boolean) —

    true if the actor has any effects,
    false otherwise

#has_key_focus ⇒ Boolean

Checks whether self is the Clutter::Actor that has key focus

Returns:

  • (Boolean) —

    true if the actor has key focus, and false otherwise

#has_overlaps ⇒ Boolean

Asks the actor's implementation whether it may contain overlapping
primitives.

For example; Clutter may use this to determine whether the painting
should be redirected to an offscreen buffer to correctly implement
the opacity property.

Custom actors can override the default response by implementing the
Clutter::ActorClass.has_overlaps() virtual function. See
clutter_actor_set_offscreen_redirect() for more information.

Returns:

  • (Boolean) —

    true if the actor may have overlapping primitives, and
    false otherwise

#has_pointer ⇒ Boolean

Checks whether an actor contains the pointer of a
Clutter::InputDevice

Returns:

  • (Boolean) —

    true if the actor contains the pointer, and
    false otherwise

#has_pointer=(has_pointer) ⇒ Boolean

Whether the actor contains the pointer of a Clutter::InputDevice
or not.

Parameters:

  • has_pointer (Boolean)

Returns:

  • (Boolean) —

    has-pointer

  • (Boolean) —

    has-pointer

#has_pointer? ⇒ Boolean

Whether the actor contains the pointer of a Clutter::InputDevice
or not.

Returns:

  • (Boolean) —

    has-pointer

#height ⇒ Clutter::gfloat

Height of the actor (in pixels). If written, forces the minimum and
natural size request of the actor to the given height. If read, returns
the allocated height if available, otherwise the height request.

The Clutter::Actor:height property is animatable.

Returns:

  • (Clutter::gfloat) —

    height

#height=(height) ⇒ Clutter::gfloat

Height of the actor (in pixels). If written, forces the minimum and
natural size request of the actor to the given height. If read, returns
the allocated height if available, otherwise the height request.

The Clutter::Actor:height property is animatable.

Parameters:

  • height (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    height

  • (Clutter::gfloat) —

    height

#hide ⇒ nil

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
Clutter::Actor:show-on-set-parent property will be set to false
as a side-effect.

Returns:

  • (nil)

#hide_all ⇒ nil

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

Returns:

  • (nil)

#insert_child_above(child, sibling) ⇒ nil

Inserts child into the list of children of self, above another
child of self or, if sibling is nil, above all the children
of self.

This function will acquire a reference on child that will only
be released when calling clutter_actor_remove_child().

This function will not take into consideration the Clutter::Actor:depth
of child.

This function will emit the Clutter::Container::actor-added signal
on self.

Parameters:

Returns:

  • (nil)

#insert_child_at_index(child, index_) ⇒ nil

Inserts child into the list of children of self, using the
given index_. If index_ is greater than the number of children
in self, or is less than 0, then the new child is added at the end.

This function will acquire a reference on child that will only
be released when calling clutter_actor_remove_child().

This function will not take into consideration the Clutter::Actor:depth
of child.

This function will emit the Clutter::Container::actor-added signal
on self.

Parameters:

  • child (Clutter::Actor) —

    a Clutter::Actor

  • index_ (Integer) —

    the index

Returns:

  • (nil)

#insert_child_below(child, sibling) ⇒ nil

Inserts child into the list of children of self, below another
child of self or, if sibling is nil, below all the children
of self.

This function will acquire a reference on child that will only
be released when calling clutter_actor_remove_child().

This function will not take into consideration the Clutter::Actor:depth
of child.

This function will emit the Clutter::Container::actor-added signal
on self.

Parameters:

Returns:

  • (nil)

#is_in_clone_paint ⇒ Boolean

Checks whether self is being currently painted by a Clutter::Clone

This function is useful only inside the ::paint virtual function
implementations or within handlers for the Clutter::Actor::paint
signal

This function should not be used by applications

Returns:

  • (Boolean) —

    true if the Clutter::Actor is currently being painted
    by a Clutter::Clone, and false otherwise

#is_mapped ⇒ Boolean

Checks whether a Clutter::Actor has been set as mapped.

See also %CLUTTER_ACTOR_IS_MAPPED and Clutter::Actor:mapped

Returns:

  • (Boolean) —

    true if the actor is mapped

#is_realized ⇒ Boolean

Checks whether a Clutter::Actor is realized.

See also %CLUTTER_ACTOR_IS_REALIZED and Clutter::Actor:realized.

Returns:

  • (Boolean) —

    true if the actor is realized

#is_rotated ⇒ Boolean

Checks whether any rotation is applied to the actor.

Returns:

  • (Boolean) —

    true if the actor is rotated.

#is_scaled ⇒ Boolean

Checks whether the actor is scaled in either dimension.

Returns:

  • (Boolean) —

    true if the actor is scaled.

#is_visible ⇒ Boolean

Checks whether an actor is marked as visible.

See also %CLUTTER_ACTOR_IS_VISIBLE and Clutter::Actor:visible.

Returns:

  • (Boolean) —

    true if the actor visible

#last_child ⇒ Clutter::Actor

The actor's last child.

Returns:

#last_child=(last_child) ⇒ Clutter::Actor

The actor's last child.

Parameters:

Returns:

#layout_manager ⇒ Clutter::LayoutManager

A delegate object for controlling the layout of the children of
an actor.

Returns:

#layout_manager=(layout_manager) ⇒ Clutter::LayoutManager

A delegate object for controlling the layout of the children of
an actor.

Parameters:

Returns:

#lower(above) ⇒ nil

Puts self below above.

Both actors must have the same parent, and the parent must implement
the Clutter::Container interface.

This function calls clutter_container_lower_child() internally.

Parameters:

Returns:

  • (nil)

#lower_bottom ⇒ nil

Lowers self to the bottom.

This function calls clutter_actor_lower() internally.

Returns:

  • (nil)

#magnification_filter ⇒ Clutter::ScalingFilter

Returns magnification-filter.

Returns:

#magnification_filter=(magnification_filter) ⇒ Clutter::ScalingFilter

Parameters:

Returns:

#map ⇒ nil

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.

Calling this function is strongly disencouraged: the default
implementation of Clutter::ActorClass.map() will map all the children
of an actor when mapping its parent.

When overriding map, it is mandatory to chain up to the parent
implementation.

Returns:

  • (nil)

#mapped=(mapped) ⇒ Boolean

Whether the actor is mapped (will be painted when the stage
to which it belongs is mapped)

Parameters:

  • mapped (Boolean)

Returns:

  • (Boolean) —

    mapped

  • (Boolean) —

    mapped

#mapped? ⇒ Boolean

Whether the actor is mapped (will be painted when the stage
to which it belongs is mapped)

Returns:

  • (Boolean) —

    mapped

#margin=(margin) ⇒ nil

Sets all the components of the margin of a Clutter::Actor.

Parameters:

  • margin (Clutter::Margin) —

    a Clutter::Margin

Returns:

  • (nil)

#margin_bottom ⇒ Clutter::gfloat

The margin (in pixels) from the bottom of the actor.

This property adds a margin to the actor's preferred size; the margin
will be automatically taken into account when allocating the actor.

The Clutter::Actor:margin-bottom property is animatable.

Returns:

  • (Clutter::gfloat) —

    margin-bottom

#margin_bottom=(margin_bottom) ⇒ Clutter::gfloat

The margin (in pixels) from the bottom of the actor.

This property adds a margin to the actor's preferred size; the margin
will be automatically taken into account when allocating the actor.

The Clutter::Actor:margin-bottom property is animatable.

Parameters:

  • margin_bottom (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    margin-bottom

  • (Clutter::gfloat) —

    margin-bottom

#margin_left ⇒ Clutter::gfloat

The margin (in pixels) from the left of the actor.

This property adds a margin to the actor's preferred size; the margin
will be automatically taken into account when allocating the actor.

The Clutter::Actor:margin-left property is animatable.

Returns:

  • (Clutter::gfloat) —

    margin-left

#margin_left=(margin_left) ⇒ Clutter::gfloat

The margin (in pixels) from the left of the actor.

This property adds a margin to the actor's preferred size; the margin
will be automatically taken into account when allocating the actor.

The Clutter::Actor:margin-left property is animatable.

Parameters:

  • margin_left (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    margin-left

  • (Clutter::gfloat) —

    margin-left

#margin_right ⇒ Clutter::gfloat

The margin (in pixels) from the right of the actor.

This property adds a margin to the actor's preferred size; the margin
will be automatically taken into account when allocating the actor.

The Clutter::Actor:margin-right property is animatable.

Returns:

  • (Clutter::gfloat) —

    margin-right

#margin_right=(margin_right) ⇒ Clutter::gfloat

The margin (in pixels) from the right of the actor.

This property adds a margin to the actor's preferred size; the margin
will be automatically taken into account when allocating the actor.

The Clutter::Actor:margin-right property is animatable.

Parameters:

  • margin_right (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    margin-right

  • (Clutter::gfloat) —

    margin-right

#margin_top ⇒ Clutter::gfloat

The margin (in pixels) from the top of the actor.

This property adds a margin to the actor's preferred size; the margin
will be automatically taken into account when allocating the actor.

The Clutter::Actor:margin-top property is animatable.

Returns:

  • (Clutter::gfloat) —

    margin-top

#margin_top=(margin_top) ⇒ Clutter::gfloat

The margin (in pixels) from the top of the actor.

This property adds a margin to the actor's preferred size; the margin
will be automatically taken into account when allocating the actor.

The Clutter::Actor:margin-top property is animatable.

Parameters:

  • margin_top (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    margin-top

  • (Clutter::gfloat) —

    margin-top

#min_height ⇒ Clutter::gfloat

A forced minimum height request for the actor, in pixels

Writing this property sets the Clutter::Actor:min-height-set property
as well, as a side effect. This property overrides the usual height
request of the actor.

Returns:

  • (Clutter::gfloat) —

    min-height

#min_height=(min_height) ⇒ Clutter::gfloat

A forced minimum height request for the actor, in pixels

Writing this property sets the Clutter::Actor:min-height-set property
as well, as a side effect. This property overrides the usual height
request of the actor.

Parameters:

  • min_height (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    min-height

  • (Clutter::gfloat) —

    min-height

#min_height_set=(min_height_set) ⇒ Boolean

This flag controls whether the Clutter::Actor:min-height property
is used

Parameters:

  • min_height_set (Boolean)

Returns:

  • (Boolean) —

    min-height-set

  • (Boolean) —

    min-height-set

#min_height_set? ⇒ Boolean

This flag controls whether the Clutter::Actor:min-height property
is used

Returns:

  • (Boolean) —

    min-height-set

#min_width ⇒ Clutter::gfloat

A forced minimum width request for the actor, in pixels

Writing this property sets the Clutter::Actor:min-width-set property
as well, as a side effect.

This property overrides the usual width request of the actor.

Returns:

  • (Clutter::gfloat) —

    min-width

#min_width=(min_width) ⇒ Clutter::gfloat

A forced minimum width request for the actor, in pixels

Writing this property sets the Clutter::Actor:min-width-set property
as well, as a side effect.

This property overrides the usual width request of the actor.

Parameters:

  • min_width (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    min-width

  • (Clutter::gfloat) —

    min-width

#min_width_set=(min_width_set) ⇒ Boolean

This flag controls whether the Clutter::Actor:min-width property
is used

Parameters:

  • min_width_set (Boolean)

Returns:

  • (Boolean) —

    min-width-set

  • (Boolean) —

    min-width-set

#min_width_set? ⇒ Boolean

This flag controls whether the Clutter::Actor:min-width property
is used

Returns:

  • (Boolean) —

    min-width-set

#minification_filter ⇒ Clutter::ScalingFilter

Returns minification-filter.

Returns:

#minification_filter=(minification_filter) ⇒ Clutter::ScalingFilter

Parameters:

Returns:

#move_anchor_point(anchor_x, anchor_y) ⇒ nil

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:

  • anchor_x (Clutter::gfloat) —

    X coordinate of the anchor point

  • anchor_y (Clutter::gfloat) —

    Y coordinate of the anchor point

Returns:

  • (nil)

#move_anchor_point_from_gravity(gravity) ⇒ nil

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:

Returns:

  • (nil)

#move_by(dx, dy) ⇒ nil

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(), or with an additional
translation, using clutter_actor_set_translation().

Parameters:

  • dx (Clutter::gfloat) —

    Distance to move Actor on X axis.

  • dy (Clutter::gfloat) —

    Distance to move Actor on Y axis.

Returns:

  • (nil)

#n_children ⇒ Integer

Retrieves the number of children of self.

Returns:

  • (Integer) —

    the number of children of an actor

#name ⇒ String

The name of the actor

Returns:

  • (String) —

    name

#name=(name) ⇒ String

The name of the actor

Parameters:

  • name (String)

Returns:

  • (String) —

    name

  • (String) —

    name

#natural_height ⇒ Clutter::gfloat

A forced natural height request for the actor, in pixels

Writing this property sets the Clutter::Actor:natural-height-set
property as well, as a side effect. This property overrides the
usual height request of the actor

Returns:

  • (Clutter::gfloat) —

    natural-height

#natural_height=(natural_height) ⇒ Clutter::gfloat

A forced natural height request for the actor, in pixels

Writing this property sets the Clutter::Actor:natural-height-set
property as well, as a side effect. This property overrides the
usual height request of the actor

Parameters:

  • natural_height (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    natural-height

  • (Clutter::gfloat) —

    natural-height

#natural_height_set=(natural_height_set) ⇒ Boolean

This flag controls whether the Clutter::Actor:natural-height property
is used

Parameters:

  • natural_height_set (Boolean)

Returns:

  • (Boolean) —

    natural-height-set

  • (Boolean) —

    natural-height-set

#natural_height_set? ⇒ Boolean

This flag controls whether the Clutter::Actor:natural-height property
is used

Returns:

  • (Boolean) —

    natural-height-set

#natural_width ⇒ Clutter::gfloat

A forced natural width request for the actor, in pixels

Writing this property sets the Clutter::Actor:natural-width-set
property as well, as a side effect. This property overrides the
usual width request of the actor

Returns:

  • (Clutter::gfloat) —

    natural-width

#natural_width=(natural_width) ⇒ Clutter::gfloat

A forced natural width request for the actor, in pixels

Writing this property sets the Clutter::Actor:natural-width-set
property as well, as a side effect. This property overrides the
usual width request of the actor

Parameters:

  • natural_width (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    natural-width

  • (Clutter::gfloat) —

    natural-width

#natural_width_set=(natural_width_set) ⇒ Boolean

This flag controls whether the Clutter::Actor:natural-width property
is used

Parameters:

  • natural_width_set (Boolean)

Returns:

  • (Boolean) —

    natural-width-set

  • (Boolean) —

    natural-width-set

#natural_width_set? ⇒ Boolean

This flag controls whether the Clutter::Actor:natural-width property
is used

Returns:

  • (Boolean) —

    natural-width-set

#needs_expand(orientation) ⇒ Boolean

Checks whether an actor, or any of its children, is set to expand
horizontally or vertically.

This function should only be called by layout managers that can
assign extra space to their children.

If you want to know whether the actor was explicitly set to expand,
use clutter_actor_get_x_expand() or clutter_actor_get_y_expand().

Parameters:

Returns:

  • (Boolean) —

    true if the actor should expand

#next_sibling ⇒ Clutter::Actor

Retrieves the sibling of self that comes after it in the list
of children of self's parent.

The returned pointer is only valid until the scene graph changes; it
is not safe to modify the list of children of self while iterating
it.

Returns:

#offscreen_redirect ⇒ Clutter::OffscreenRedirect

Determines the conditions in which the actor will be redirected
to an offscreen framebuffer while being painted. For example this
can be used to cache an actor in a framebuffer or for improved
handling of transparent actors. See
clutter_actor_set_offscreen_redirect() for details.

Returns:

#offscreen_redirect=(offscreen_redirect) ⇒ Clutter::OffscreenRedirect

Determines the conditions in which the actor will be redirected
to an offscreen framebuffer while being painted. For example this
can be used to cache an actor in a framebuffer or for improved
handling of transparent actors. See
clutter_actor_set_offscreen_redirect() for details.

Parameters:

Returns:

#opacity ⇒ Integer

Opacity of an actor, between 0 (fully transparent) and
255 (fully opaque)

The Clutter::Actor:opacity property is animatable.

Returns:

  • (Integer) —

    opacity

#opacity=(opacity) ⇒ Integer

Opacity of an actor, between 0 (fully transparent) and
255 (fully opaque)

The Clutter::Actor:opacity property is animatable.

Parameters:

  • opacity (Integer)

Returns:

  • (Integer) —

    opacity

  • (Integer) —

    opacity

#paint ⇒ nil

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 is context-aware, and will either cause a
regular paint or a pick paint.

This function will emit the Clutter::Actor::paint signal or
the Clutter::Actor::pick signal, depending on the context.

This function does not paint the actor if the actor is set to 0,
unless it is performing a pick paint.

Returns:

  • (nil)

#paint_opacity ⇒ Integer

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:

  • (Integer) —

    The actor opacity value.

#paint_visibility ⇒ Boolean

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:

  • (Boolean) —

    true if the actor is visibile and will be painted.

#paint_volume ⇒ Clutter::PaintVolume

Retrieves the paint volume of the passed Clutter::Actor, or nil
when a paint volume can't be determined.

The paint volume is defined as the 3D space occupied by an actor
when being painted.

This function will call the Clutter::ActorClass.get_paint_volume()
virtual function of the Clutter::Actor class. Sub-classes of #ClutterActor
should not usually care about overriding the default implementation,
unless they are, for instance: painting outside their allocation, or
actors with a depth factor (not in terms of Clutter::Actor:depth but real
3D depth).

Note: 2D actors overriding Clutter::ActorClass.get_paint_volume()
should ensure that their volume has a depth of 0. (This will be true
as long as you don't call clutter_paint_volume_set_depth().)

Returns:

  • (Clutter::PaintVolume) —

    a pointer to a Clutter::PaintVolume,
    or nil if no volume could be determined. The returned pointer
    is not guaranteed to be valid across multiple frames; if you want
    to keep it, you will need to copy it using clutter_paint_volume_copy().

#pango_context ⇒ Pango::Context

Retrieves the Pango::Context 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 Clutter::Actor and it will be updated each time the options
stored by the Clutter::Backend change.

You can use the returned Pango::Context to create a #PangoLayout
and render text using cogl_pango_render_layout() to reuse the
glyphs cache also used by Clutter.

Returns:

  • (Pango::Context) —

    the Pango::Context for a #ClutterActor.
    The returned Pango::Context is owned by the actor and should not be
    unreferenced by the application code

#parent ⇒ Clutter::Actor

Retrieves the parent of self.

Returns:

  • (Clutter::Actor) —

    The Clutter::Actor parent, or nil
    if no parent is set

#parent=(parent) ⇒ nil

Sets the parent of self to parent.

This function will result in parent acquiring a reference on self,
eventually by sinking its floating reference first. The reference
will be released by clutter_actor_unparent().

This function should only be called by legacy Clutter::Actors
implementing the Clutter::Container interface.

Parameters:

Returns:

  • (nil)

#pivot_point ⇒ Clutter::Point

The point around which the scaling and rotation transformations occur.

The pivot point is expressed in normalized coordinates space, with (0, 0)
being the top left corner of the actor and (1, 1) the bottom right corner
of the actor.

The default pivot point is located at (0, 0).

The Clutter::Actor:pivot-point property is animatable.

Returns:

#pivot_point=(pivot_point) ⇒ Clutter::Point

The point around which the scaling and rotation transformations occur.

The pivot point is expressed in normalized coordinates space, with (0, 0)
being the top left corner of the actor and (1, 1) the bottom right corner
of the actor.

The default pivot point is located at (0, 0).

The Clutter::Actor:pivot-point property is animatable.

Parameters:

Returns:

#pivot_point_z ⇒ Clutter::gfloat

The Z component of the Clutter::Actor:pivot-point, expressed as a value
along the Z axis.

The Clutter::Actor:pivot-point-z property is animatable.

Returns:

  • (Clutter::gfloat) —

    pivot-point-z

#pivot_point_z=(pivot_point_z) ⇒ Clutter::gfloat

The Z component of the Clutter::Actor:pivot-point, expressed as a value
along the Z axis.

The Clutter::Actor:pivot-point-z property is animatable.

Parameters:

  • pivot_point_z (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    pivot-point-z

  • (Clutter::gfloat) —

    pivot-point-z

#pop_internal ⇒ nil

Disables the effects of clutter_actor_push_internal().

Returns:

  • (nil)

#position ⇒ Clutter::Point

The position of the origin of the actor.

This property is a shorthand for setting and getting the
Clutter::Actor:x and #ClutterActor:y properties at the same
time.

The Clutter::Actor:position property is animatable.

Returns:

#position=(position) ⇒ Clutter::Point

The position of the origin of the actor.

This property is a shorthand for setting and getting the
Clutter::Actor:x and #ClutterActor:y properties at the same
time.

The Clutter::Actor:position property is animatable.

Parameters:

Returns:

#previous_sibling ⇒ Clutter::Actor

Retrieves the sibling of self that comes before it in the list
of children of self's parent.

The returned pointer is only valid until the scene graph changes; it
is not safe to modify the list of children of self while iterating
it.

Returns:

#push_internal ⇒ nil

Should be used by actors implementing the Clutter::Container and with
internal children added through clutter_actor_set_parent(), for instance:

  static void
  my_actor_init (MyActor *self)
  {
    self->priv = my_actor_get_instance_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:

  • (nil)

#queue_redraw ⇒ nil

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

When you are implementing a custom actor you must queue a redraw
whenever some private state changes that will affect painting or
picking of your actor.

Returns:

  • (nil)

#queue_redraw_with_clip(clip) ⇒ nil

Queues a redraw on self limited to a specific, actor-relative
rectangular area.

If clip is nil this function is equivalent to
clutter_actor_queue_redraw().

Parameters:

  • clip (cairo::RectangleInt) —

    a rectangular clip region, or nil

Returns:

  • (nil)

#queue_relayout ⇒ nil

Indicates that the actor's size request or other layout-affecting
properties may have changed. This function is used inside Clutter::Actor
subclass implementations, not by applications directly.

Queueing a new layout automatically queues a redraw as well.

Returns:

  • (nil)

#raise(below) ⇒ nil

Puts self above below.

Both actors must have the same parent, and the parent must implement
the Clutter::Container interface

This function calls clutter_container_raise_child() internally.

Parameters:

Returns:

  • (nil)

#raise_top ⇒ nil

Raises self to the top.

This function calls clutter_actor_raise() internally.

Returns:

  • (nil)

#reactive ⇒ Boolean

Checks whether actor is marked as reactive.

Returns:

  • (Boolean) —

    true if the actor is reactive

#reactive=(reactive) ⇒ Boolean

Whether the actor is reactive to events or not

Only reactive actors will emit event-related signals

Parameters:

  • reactive (Boolean)

Returns:

  • (Boolean) —

    reactive

  • (Boolean) —

    reactive

#reactive? ⇒ Boolean

Whether the actor is reactive to events or not

Only reactive actors will emit event-related signals

Returns:

  • (Boolean) —

    reactive

#realize ⇒ nil

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:

  • (nil)

#realized=(realized) ⇒ Boolean

Whether the actor has been realized

Parameters:

  • realized (Boolean)

Returns:

  • (Boolean) —

    realized

  • (Boolean) —

    realized

#realized? ⇒ Boolean

Whether the actor has been realized

Returns:

  • (Boolean) —

    realized

#remove_action(action) ⇒ nil

Removes action from the list of actions applied to self

The reference held by self on the Clutter::Action will be released

Parameters:

Returns:

  • (nil)

#remove_action_by_name(name) ⇒ nil

Removes the Clutter::Action with the given name from the list
of actions applied to self

Parameters:

  • name (String) —

    the name of the action to remove

Returns:

  • (nil)

#remove_all_children ⇒ nil

Removes all children of self.

This function releases the reference added by inserting a child actor
in the list of children of self.

If the reference count of a child drops to zero, the child will be
destroyed. If you want to ensure the destruction of all the children
of self, use clutter_actor_destroy_all_children().

Returns:

  • (nil)

#remove_all_transitions ⇒ nil

Removes all transitions associated to self.

Returns:

  • (nil)

#remove_child(child) ⇒ nil

Removes child from the children of self.

This function will release the reference added by
clutter_actor_add_child(), so if you want to keep using child
you will have to acquire a referenced on it before calling this
function.

This function will emit the Clutter::Container::actor-removed
signal on self.

Parameters:

Returns:

  • (nil)

#remove_clip ⇒ nil

Removes clip area from self.

Returns:

  • (nil)

#remove_constraint(constraint) ⇒ nil

Removes constraint from the list of constraints applied to self

The reference held by self on the Clutter::Constraint will be released

Parameters:

Returns:

  • (nil)

#remove_constraint_by_name(name) ⇒ nil

Removes the Clutter::Constraint with the given name from the list
of constraints applied to self

Parameters:

  • name (String) —

    the name of the constraint to remove

Returns:

  • (nil)

#remove_effect(effect) ⇒ nil

Removes effect from the list of effects applied to self

The reference held by self on the Clutter::Effect will be released

Parameters:

Returns:

  • (nil)

#remove_effect_by_name(name) ⇒ nil

Removes the Clutter::Effect with the given name from the list
of effects applied to self

Parameters:

  • name (String) —

    the name of the effect to remove

Returns:

  • (nil)

#remove_transition(name) ⇒ nil

Removes the transition stored inside a Clutter::Actor using name
identifier.

If the transition is currently in progress, it will be stopped.

This function releases the reference acquired when the transition
was added to the Clutter::Actor.

Parameters:

  • name (String) —

    the name of the transition to remove

Returns:

  • (nil)

#reparent(new_parent) ⇒ nil

Resets the parent actor of self.

This function is logically equivalent to calling clutter_actor_unparent()
and clutter_actor_set_parent(), but more efficiently implemented, as it
ensures the child is not finalized when unparented, and emits the
Clutter::Actor::parent-set signal only once.

In reality, calling this function is less useful than it sounds, as some
application code may rely on changes in the intermediate state between
removal and addition of the actor from its old parent to the new_parent.
Thus, it is strongly encouraged to avoid using this function in application
code.

Parameters:

Returns:

  • (nil)

#replace_child(old_child, new_child) ⇒ nil

Replaces old_child with new_child in the list of children of self.

Parameters:

Returns:

  • (nil)

#request_mode ⇒ Clutter::RequestMode

Request mode for the Clutter::Actor. The request mode determines the
type of geometry management used by the actor, either height for width
(the default) or width for height.

For actors implementing height for width, the parent container should get
the preferred width first, and then the preferred height for that width.

For actors implementing width for height, the parent container should get
the preferred height first, and then the preferred width for that height.

For instance:

  ClutterRequestMode mode;
  gfloat natural_width, min_width;
  gfloat natural_height, min_height;

  mode = clutter_actor_get_request_mode (child);
  if (mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
    {
      clutter_actor_get_preferred_width (child, -1,
                                         &min_width,
                                         &natural_width);
      clutter_actor_get_preferred_height (child, natural_width,
                                          &min_height,
                                          &natural_height);
    }
  else if (mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
    {
      clutter_actor_get_preferred_height (child, -1,
                                          &min_height,
                                          &natural_height);
      clutter_actor_get_preferred_width (child, natural_height,
                                         &min_width,
                                         &natural_width);
    }
  else if (mode == CLUTTER_REQUEST_CONTENT_SIZE)
    {
      ClutterContent *content = clutter_actor_get_content (child);

      min_width, min_height = 0;
      natural_width = natural_height = 0;

      if (content != NULL)
        clutter_content_get_preferred_size (content, &natural_width, &natural_height);
    }

will retrieve the minimum and natural width and height depending on the
preferred request mode of the Clutter::Actor "child".

The clutter_actor_get_preferred_size() function will implement this
check for you.

Returns:

#request_mode=(request_mode) ⇒ Clutter::RequestMode

Request mode for the Clutter::Actor. The request mode determines the
type of geometry management used by the actor, either height for width
(the default) or width for height.

For actors implementing height for width, the parent container should get
the preferred width first, and then the preferred height for that width.

For actors implementing width for height, the parent container should get
the preferred height first, and then the preferred width for that height.

For instance:

  ClutterRequestMode mode;
  gfloat natural_width, min_width;
  gfloat natural_height, min_height;

  mode = clutter_actor_get_request_mode (child);
  if (mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
    {
      clutter_actor_get_preferred_width (child, -1,
                                         &min_width,
                                         &natural_width);
      clutter_actor_get_preferred_height (child, natural_width,
                                          &min_height,
                                          &natural_height);
    }
  else if (mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
    {
      clutter_actor_get_preferred_height (child, -1,
                                          &min_height,
                                          &natural_height);
      clutter_actor_get_preferred_width (child, natural_height,
                                         &min_width,
                                         &natural_width);
    }
  else if (mode == CLUTTER_REQUEST_CONTENT_SIZE)
    {
      ClutterContent *content = clutter_actor_get_content (child);

      min_width, min_height = 0;
      natural_width = natural_height = 0;

      if (content != NULL)
        clutter_content_get_preferred_size (content, &natural_width, &natural_height);
    }

will retrieve the minimum and natural width and height depending on the
preferred request mode of the Clutter::Actor "child".

The clutter_actor_get_preferred_size() function will implement this
check for you.

Parameters:

Returns:

#restore_easing_state ⇒ nil

Restores the easing state as it was prior to a call to
clutter_actor_save_easing_state().

Returns:

  • (nil)

#rotation_angle_x ⇒ Float

The rotation angle on the X axis.

The Clutter::Actor:rotation-angle-x property is animatable.

Returns:

  • (Float) —

    rotation-angle-x

#rotation_angle_x=(rotation_angle_x) ⇒ Float

The rotation angle on the X axis.

The Clutter::Actor:rotation-angle-x property is animatable.

Parameters:

  • rotation_angle_x (Float)

Returns:

  • (Float) —

    rotation-angle-x

  • (Float) —

    rotation-angle-x

#rotation_angle_y ⇒ Float

The rotation angle on the Y axis

The Clutter::Actor:rotation-angle-y property is animatable.

Returns:

  • (Float) —

    rotation-angle-y

#rotation_angle_y=(rotation_angle_y) ⇒ Float

The rotation angle on the Y axis

The Clutter::Actor:rotation-angle-y property is animatable.

Parameters:

  • rotation_angle_y (Float)

Returns:

  • (Float) —

    rotation-angle-y

  • (Float) —

    rotation-angle-y

#rotation_angle_z ⇒ Float

The rotation angle on the Z axis

The Clutter::Actor:rotation-angle-z property is animatable.

Returns:

  • (Float) —

    rotation-angle-z

#rotation_angle_z=(rotation_angle_z) ⇒ Float

The rotation angle on the Z axis

The Clutter::Actor:rotation-angle-z property is animatable.

Parameters:

  • rotation_angle_z (Float)

Returns:

  • (Float) —

    rotation-angle-z

  • (Float) —

    rotation-angle-z

#rotation_center_x ⇒ Clutter::Vertex

The rotation center on the X axis.

Returns:

  • (Clutter::Vertex) —

    rotation-center-x

#rotation_center_x=(rotation_center_x) ⇒ Clutter::Vertex

The rotation center on the X axis.

Parameters:

  • rotation_center_x (Clutter::Vertex)

Returns:

  • (Clutter::Vertex) —

    rotation-center-x

  • (Clutter::Vertex) —

    rotation-center-x

#rotation_center_y ⇒ Clutter::Vertex

The rotation center on the Y axis.

Returns:

  • (Clutter::Vertex) —

    rotation-center-y

#rotation_center_y=(rotation_center_y) ⇒ Clutter::Vertex

The rotation center on the Y axis.

Parameters:

  • rotation_center_y (Clutter::Vertex)

Returns:

  • (Clutter::Vertex) —

    rotation-center-y

  • (Clutter::Vertex) —

    rotation-center-y

#rotation_center_z ⇒ Clutter::Vertex

The rotation center on the Z axis.

Returns:

  • (Clutter::Vertex) —

    rotation-center-z

#rotation_center_z=(rotation_center_z) ⇒ Clutter::Vertex

The rotation center on the Z axis.

Parameters:

  • rotation_center_z (Clutter::Vertex)

Returns:

  • (Clutter::Vertex) —

    rotation-center-z

  • (Clutter::Vertex) —

    rotation-center-z

#rotation_center_z_gravity ⇒ Clutter::Gravity

The rotation center on the Z axis expressed as a Clutter::Gravity.

Returns:

#rotation_center_z_gravity=(rotation_center_z_gravity) ⇒ Clutter::Gravity

The rotation center on the Z axis expressed as a Clutter::Gravity.

Parameters:

Returns:

#save_easing_state ⇒ nil

Saves the current easing state for animatable properties, and creates
a new state with the default values for easing mode and duration.

New transitions created after calling this function will inherit the
duration, easing mode, and delay of the new easing state; this also
applies to transitions modified in flight.

Returns:

  • (nil) 


21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/clutter/actor.rb', line 21

def save_easing_state
  if block_given?
    save_easing_state_without_block
    begin
      yield
    ensure
      restore_easing_state
    end
  else
    save_easing_state_without_block
  end
end

#save_easing_state_without_block ⇒ nil

Saves the current easing state for animatable properties, and creates
a new state with the default values for easing mode and duration.

New transitions created after calling this function will inherit the
duration, easing mode, and delay of the new easing state; this also
applies to transitions modified in flight.
TODO: use prepend after Ruby 1.9 support is dropped.

Returns:

  • (nil) 



# File 'lib/clutter/actor.rb', line 20

#scale_center_x ⇒ Clutter::gfloat

The horizontal center point for scaling

Returns:

  • (Clutter::gfloat) —

    scale-center-x

#scale_center_x=(scale_center_x) ⇒ Clutter::gfloat

The horizontal center point for scaling

Parameters:

  • scale_center_x (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    scale-center-x

  • (Clutter::gfloat) —

    scale-center-x

#scale_center_y ⇒ Clutter::gfloat

The vertical center point for scaling

Returns:

  • (Clutter::gfloat) —

    scale-center-y

#scale_center_y=(scale_center_y) ⇒ Clutter::gfloat

The vertical center point for scaling

Parameters:

  • scale_center_y (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    scale-center-y

  • (Clutter::gfloat) —

    scale-center-y

#scale_gravity ⇒ Clutter::Gravity

The center point for scaling expressed as a Clutter::Gravity

Returns:

#scale_gravity=(scale_gravity) ⇒ Clutter::Gravity

The center point for scaling expressed as a Clutter::Gravity

Parameters:

Returns:

#scale_x ⇒ Float

The horizontal scale of the actor.

The Clutter::Actor:scale-x property is animatable.

Returns:

  • (Float) —

    scale-x

#scale_x=(scale_x) ⇒ Float

The horizontal scale of the actor.

The Clutter::Actor:scale-x property is animatable.

Parameters:

  • scale_x (Float)

Returns:

  • (Float) —

    scale-x

  • (Float) —

    scale-x

#scale_y ⇒ Float

The vertical scale of the actor.

The Clutter::Actor:scale-y property is animatable.

Returns:

  • (Float) —

    scale-y

#scale_y=(scale_y) ⇒ Float

The vertical scale of the actor.

The Clutter::Actor:scale-y property is animatable.

Parameters:

  • scale_y (Float)

Returns:

  • (Float) —

    scale-y

  • (Float) —

    scale-y

#scale_z ⇒ Float

The scale factor of the actor along the Z axis.

The Clutter::Actor:scale-y property is animatable.

Returns:

  • (Float) —

    scale-z

#scale_z=(scale_z) ⇒ Float

The scale factor of the actor along the Z axis.

The Clutter::Actor:scale-y property is animatable.

Parameters:

  • scale_z (Float)

Returns:

  • (Float) —

    scale-z

  • (Float) —

    scale-z

#set_allocation(box, flags) ⇒ nil

Stores the allocation of self as defined by box.

This function can only be called from within the implementation of
the Clutter::ActorClass.allocate() virtual function.

The allocation should have been adjusted to take into account constraints,
alignment, and margin properties. If you are implementing a Clutter::Actor
subclass that provides its own layout management policy for its children
instead of using a Clutter::LayoutManager delegate, you should not call
this function on the children of self; instead, you should call
clutter_actor_allocate(), which will adjust the allocation box for
you.

This function should only be used by subclasses of Clutter::Actor
that wish to store their allocation but cannot chain up to the
parent's implementation; the default implementation of the
Clutter::ActorClass.allocate() virtual function will call this
function.

It is important to note that, while chaining up was the recommended
behaviour for Clutter::Actor subclasses prior to the introduction of
this function, it is recommended to call clutter_actor_set_allocation()
instead.

If the Clutter::Actor is using a #ClutterLayoutManager delegate object
to handle the allocation of its children, this function will call
the clutter_layout_manager_allocate() function only if the
%CLUTTER_DELEGATE_LAYOUT flag is set on flags, otherwise it is
expected that the subclass will call clutter_layout_manager_allocate()
by itself. For instance, the following code:

static void
my_actor_allocate (ClutterActor *actor,
                   const ClutterActorBox *allocation,
                   ClutterAllocationFlags flags)
{
  ClutterLayoutManager *layout;
  ClutterActorBox new_alloc;

  adjust_allocation (allocation, &new_alloc);

  clutter_actor_set_allocation (actor, &new_alloc, flags);

  layout = clutter_actor_get_layout_manager (actor);
  clutter_layout_manager_allocate (layout,
                                   CLUTTER_CONTAINER (actor),
                                   &new_alloc,
                                   flags);
}

Parameters:

Returns:

  • (nil)

#set_anchor_point(anchor_x, anchor_y) ⇒ nil

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:

  • anchor_x (Clutter::gfloat) —

    X coordinate of the anchor point

  • anchor_y (Clutter::gfloat) —

    Y coordinate of the anchor point

Returns:

  • (nil)

#set_child_above_sibling(child, sibling) ⇒ nil

Sets child to be above sibling in the list of children of self.

If sibling is nil, child will be the new last child of self.

This function is logically equivalent to removing child and using
clutter_actor_insert_child_above(), but it will not emit signals
or change state on child.

Parameters:

Returns:

  • (nil)

#set_child_at_index(child, index_) ⇒ nil

Changes the index of child in the list of children of self.

This function is logically equivalent to removing child and
calling clutter_actor_insert_child_at_index(), but it will not
emit signals or change state on child.

Parameters:

  • child (Clutter::Actor) —

    a Clutter::Actor child of self

  • index_ (Integer) —

    the new index for child

Returns:

  • (nil)

#set_child_below_sibling(child, sibling) ⇒ nil

Sets child to be below sibling in the list of children of self.

If sibling is nil, child will be the new first child of self.

This function is logically equivalent to removing self and using
clutter_actor_insert_child_below(), but it will not emit signals
or change state on child.

Parameters:

Returns:

  • (nil)

#set_clip(xoff, yoff, width, height) ⇒ nil

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:

  • xoff (Clutter::gfloat) —

    X offset of the clip rectangle

  • yoff (Clutter::gfloat) —

    Y offset of the clip rectangle

  • width (Clutter::gfloat) —

    Width of the clip rectangle

  • height (Clutter::gfloat) —

    Height of the clip rectangle

Returns:

  • (nil)

#set_content_scaling_filters(min_filter, mag_filter) ⇒ nil

Sets the minification and magnification filter to be applied when
scaling the Clutter::Actor:content of a #ClutterActor.

The Clutter::Actor:minification-filter will be used when reducing
the size of the content; the Clutter::Actor:magnification-filter
will be used when increasing the size of the content.

Parameters:

Returns:

  • (nil)

#set_pivot_point(pivot_x, pivot_y) ⇒ nil

Sets the position of the Clutter::Actor:pivot-point around which the
scaling and rotation transformations occur.

The pivot point's coordinates are in normalized space, with the (0, 0)
point being the top left corner of the actor, and the (1, 1) point being
the bottom right corner.

Parameters:

  • pivot_x (Clutter::gfloat) —

    the normalized X coordinate of the pivot point

  • pivot_y (Clutter::gfloat) —

    the normalized Y coordinate of the pivot point

Returns:

  • (nil)

#set_position(x, y) ⇒ nil

Sets the actor's fixed position in pixels relative to any parent
actor.

If a layout manager is in use, this position will override the
layout manager and force a fixed position.

Parameters:

  • x (Clutter::gfloat) —

    New left position of actor in pixels.

  • y (Clutter::gfloat) —

    New top position of actor in pixels.

Returns:

  • (nil)

#set_rotation(axis, angle, x, y, z) ⇒ nil

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:

  • axis (Clutter::RotateAxis) —

    the axis of rotation

  • angle (Float) —

    the angle of rotation

  • x (Clutter::gfloat) —

    X coordinate of the rotation center

  • y (Clutter::gfloat) —

    Y coordinate of the rotation center

  • z (Clutter::gfloat) —

    Z coordinate of the rotation center

Returns:

  • (nil)

#set_rotation_angle(axis, angle) ⇒ nil

Sets the angle of rotation of a Clutter::Actor on the given axis.

This function is a convenience for setting the rotation properties
Clutter::Actor:rotation-angle-x, #ClutterActor:rotation-angle-y,
and Clutter::Actor:rotation-angle-z.

The center of rotation is established by the Clutter::Actor:pivot-point
property.

Parameters:

  • axis (Clutter::RotateAxis) —

    the axis to set the angle one

  • angle (Float) —

    the angle of rotation, in degrees

Returns:

  • (nil)

#set_scale(scale_x, scale_y) ⇒ nil

Scales an actor with the given factors.

The scale transformation is relative the the Clutter::Actor:pivot-point.

The Clutter::Actor:scale-x and #ClutterActor:scale-y properties are
animatable.

Parameters:

  • scale_x (Float) —

    double factor to scale actor by horizontally.

  • scale_y (Float) —

    double factor to scale actor by vertically.

Returns:

  • (nil)

#set_scale_full(scale_x, scale_y, center_x, center_y) ⇒ nil

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).

The Clutter::Actor:scale-x and #ClutterActor:scale-y properties
are animatable.

Parameters:

  • scale_x (Float) —

    double factor to scale actor by horizontally.

  • scale_y (Float) —

    double factor to scale actor by vertically.

  • center_x (Clutter::gfloat) —

    X coordinate of the center of the scaling

  • center_y (Clutter::gfloat) —

    Y coordinate of the center of the scaling

Returns:

  • (nil)

#set_scale_with_gravity(scale_x, scale_y, gravity) ⇒ nil

Scales an actor with the given factors around the given
center point. The center point is specified as one of the compass
directions in Clutter::Gravity. 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.

The Clutter::Actor:scale-x and #ClutterActor:scale-y properties are
animatable.

Parameters:

  • scale_x (Float) —

    double factor to scale actor by horizontally.

  • scale_y (Float) —

    double factor to scale actor by vertically.

  • gravity (Clutter::Gravity) —

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

Returns:

  • (nil)

#set_shader_param(param, value) ⇒ nil

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

Parameters:

  • param (String) —

    the name of the parameter

  • value (GObject::Value) —

    the value of the parameter

Returns:

  • (nil)

#set_shader_param_float(param, value) ⇒ nil

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

Parameters:

  • param (String) —

    the name of the parameter

  • value (Clutter::gfloat) —

    the value of the parameter

Returns:

  • (nil)

#set_shader_param_int(param, value) ⇒ nil

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

Parameters:

  • param (String) —

    the name of the parameter

  • value (Integer) —

    the value of the parameter

Returns:

  • (nil)

#set_size(width, height) ⇒ nil

Sets the actor's size request in pixels. This overrides any
"normal" size request the actor would have. For example
a text actor might normally request the size of the text;
this function would force a specific size instead.

If width and/or height are -1 the actor will use its
"normal" size request instead of overriding it, i.e.
you can "unset" the size with -1.

This function sets or unsets both the minimum and natural size.

Parameters:

  • width (Clutter::gfloat) —

    New width of actor in pixels, or -1

  • height (Clutter::gfloat) —

    New height of actor in pixels, or -1

Returns:

  • (nil)

#set_translation(translate_x, translate_y, translate_z) ⇒ nil

Sets an additional translation transformation on a Clutter::Actor,
relative to the Clutter::Actor:pivot-point.

Parameters:

  • translate_x (Clutter::gfloat) —

    the translation along the X axis

  • translate_y (Clutter::gfloat) —

    the translation along the Y axis

  • translate_z (Clutter::gfloat) —

    the translation along the Z axis

Returns:

  • (nil)

#set_z_rotation_from_gravity(angle, gravity) ⇒ nil

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:

  • angle (Float) —

    the angle of rotation

  • gravity (Clutter::Gravity) —

    the center point of the rotation

Returns:

  • (nil)

#shader ⇒ Clutter::Shader

Queries the currently set Clutter::Shader on self.

Returns:

  • (Clutter::Shader) —

    The currently set Clutter::Shader
    or nil if no shader is set.

#shader=(shader) ⇒ Boolean

Sets the Clutter::Shader to be used when rendering self.

If shader is nil this function will unset any currently set shader
for the actor.

Any Clutter::Effect applied to self will take the precedence
over the Clutter::Shader set using this function.

Parameters:

  • shader (Clutter::Shader) —

    a Clutter::Shader or nil to unset the shader.

Returns:

  • (Boolean) —

    true if the shader was successfully applied
    or removed

#should_pick_paint ⇒ Boolean

Should be called inside the implementation of the
Clutter::Actor::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.

Returns:

  • (Boolean) —

    true if the actor should paint its silhouette,
    false otherwise

#show ⇒ nil

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
Clutter::Actor:show-on-set-parent will be set to true as a side
effect.

Returns:

  • (nil)

#show_all ⇒ nil

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

Returns:

  • (nil)

#show_on_set_parent=(show_on_set_parent) ⇒ Boolean

If true, the actor is automatically shown when parented.

Calling clutter_actor_hide() on an actor which has not been
parented will set this property to false as a side effect.

Parameters:

  • show_on_set_parent (Boolean)

Returns:

  • (Boolean) —

    show-on-set-parent

  • (Boolean) —

    show-on-set-parent

#show_on_set_parent? ⇒ Boolean

If true, the actor is automatically shown when parented.

Calling clutter_actor_hide() on an actor which has not been
parented will set this property to false as a side effect.

Returns:

  • (Boolean) —

    show-on-set-parent

#size ⇒ Clutter::Size

The size of the actor.

This property is a shorthand for setting and getting the
Clutter::Actor:width and #ClutterActor:height at the same time.

The Clutter::Actor:size property is animatable.

Returns:

  • (Clutter::Size) —

    size

#size=(size) ⇒ Clutter::Size

The size of the actor.

This property is a shorthand for setting and getting the
Clutter::Actor:width and #ClutterActor:height at the same time.

The Clutter::Actor:size property is animatable.

Parameters:

  • size (Clutter::Size)

Returns:

  • (Clutter::Size) —

    size

  • (Clutter::Size) —

    size

#stage ⇒ Clutter::Stage

Retrieves the Clutter::Stage where actor is contained.

Returns:

#text_direction ⇒ Clutter::TextDirection

The direction of the text inside a Clutter::Actor.

Returns:

#text_direction=(text_direction) ⇒ Clutter::TextDirection

The direction of the text inside a Clutter::Actor.

Parameters:

Returns:

#transform ⇒ Clutter::Matrix

Overrides the transformations of a Clutter::Actor with a custom
matrix.

The matrix specified by the Clutter::Actor:transform property is
applied to the actor and its children relative to the actor's
Clutter::Actor:allocation and #ClutterActor:pivot-point.

Application code should rarely need to use this function directly.

Setting this property with a Clutter::Matrix will set the
Clutter::Actor:transform-set property to true as a side effect;
setting this property with nil will set the
Clutter::Actor:transform-set property to false.

The Clutter::Actor:transform property is animatable.

Returns:

  • (Clutter::Matrix) —

    transform

#transform=(transform) ⇒ Clutter::Matrix

Overrides the transformations of a Clutter::Actor with a custom
matrix.

The matrix specified by the Clutter::Actor:transform property is
applied to the actor and its children relative to the actor's
Clutter::Actor:allocation and #ClutterActor:pivot-point.

Application code should rarely need to use this function directly.

Setting this property with a Clutter::Matrix will set the
Clutter::Actor:transform-set property to true as a side effect;
setting this property with nil will set the
Clutter::Actor:transform-set property to false.

The Clutter::Actor:transform property is animatable.

Parameters:

  • transform (Clutter::Matrix)

Returns:

  • (Clutter::Matrix) —

    transform

  • (Clutter::Matrix) —

    transform

#transform_set=(transform_set) ⇒ Boolean

Whether the Clutter::Actor:transform property is set.

Parameters:

  • transform_set (Boolean)

Returns:

  • (Boolean) —

    transform-set

  • (Boolean) —

    transform-set

#transform_set? ⇒ Boolean

Whether the Clutter::Actor:transform property is set.

Returns:

  • (Boolean) —

    transform-set

#transform_stage_point(x, y, x_out, y_out) ⇒ Boolean

This function translates screen coordinates (x, y) to
coordinates relative to the actor. For example, it can be used to translate
screen events from global screen coordinates into actor-local coordinates.

The conversion can fail, notably if the transform stack results in the
actor being projected on the screen as a mere line.

The conversion should not be expected to be pixel-perfect due to the
nature of the operation. In general the error grows when the skewing
of the actor rectangle on screen increases.

This function can be computationally intensive.

This function only works when the allocation is up-to-date, i.e. inside of
the Clutter::ActorClass.paint() implementation

Parameters:

  • x (Clutter::gfloat) —

    x screen coordinate of the point to unproject

  • y (Clutter::gfloat) —

    y screen coordinate of the point to unproject

  • x_out (Clutter::gfloat) —

    return location for the unprojected x coordinance

  • y_out (Clutter::gfloat) —

    return location for the unprojected y coordinance

Returns:

  • (Boolean) —

    true if conversion was successful.

#translation_x ⇒ Clutter::gfloat

An additional translation applied along the X axis, relative
to the actor's Clutter::Actor:pivot-point.

The Clutter::Actor:translation-x property is animatable.

Returns:

  • (Clutter::gfloat) —

    translation-x

#translation_x=(translation_x) ⇒ Clutter::gfloat

An additional translation applied along the X axis, relative
to the actor's Clutter::Actor:pivot-point.

The Clutter::Actor:translation-x property is animatable.

Parameters:

  • translation_x (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    translation-x

  • (Clutter::gfloat) —

    translation-x

#translation_y ⇒ Clutter::gfloat

An additional translation applied along the Y axis, relative
to the actor's Clutter::Actor:pivot-point.

The Clutter::Actor:translation-y property is animatable.

Returns:

  • (Clutter::gfloat) —

    translation-y

#translation_y=(translation_y) ⇒ Clutter::gfloat

An additional translation applied along the Y axis, relative
to the actor's Clutter::Actor:pivot-point.

The Clutter::Actor:translation-y property is animatable.

Parameters:

  • translation_y (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    translation-y

  • (Clutter::gfloat) —

    translation-y

#translation_z ⇒ Clutter::gfloat

An additional translation applied along the Z axis, relative
to the actor's Clutter::Actor:pivot-point.

The Clutter::Actor:translation-z property is animatable.

Returns:

  • (Clutter::gfloat) —

    translation-z

#translation_z=(translation_z) ⇒ Clutter::gfloat

An additional translation applied along the Z axis, relative
to the actor's Clutter::Actor:pivot-point.

The Clutter::Actor:translation-z property is animatable.

Parameters:

  • translation_z (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    translation-z

  • (Clutter::gfloat) —

    translation-z

#unmap ⇒ nil

Unsets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly
unmaps its children if they were mapped.

Calling this function is not encouraged: the default Clutter::Actor
implementation of Clutter::ActorClass.unmap() will also unmap any
eventual children by default when their parent is unmapped.

When overriding Clutter::ActorClass.unmap(), it is mandatory to
chain up to the parent implementation.

It is important to note that the implementation of the
Clutter::ActorClass.unmap() virtual function may be called after
the Clutter::ActorClass.destroy() or the #GObjectClass.dispose()
implementation, but it is guaranteed to be called before the
GObject::Class.finalize() implementation.

Returns:

  • (nil)

#unparent ⇒ nil

Removes the parent of self.

This will cause the parent of self to release the reference
acquired when calling clutter_actor_set_parent(), so if you
want to keep self you will have to acquire a reference of
your own, through g_object_ref().

This function should only be called by legacy Clutter::Actors
implementing the Clutter::Container interface.

Returns:

  • (nil)

#unrealize ⇒ nil

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 be called by application code.

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.

Returns:

  • (nil)

#unset_flags(flags) ⇒ nil

Unsets flags on self

This function will emit notifications for the changed properties

Parameters:

Returns:

  • (nil)

#visible=(visible) ⇒ Boolean

Whether the actor is set to be visible or not

See also Clutter::Actor:mapped

Parameters:

  • visible (Boolean)

Returns:

  • (Boolean) —

    visible

  • (Boolean) —

    visible

#visible? ⇒ Boolean

Whether the actor is set to be visible or not

See also Clutter::Actor:mapped

Returns:

  • (Boolean) —

    visible

#width ⇒ Clutter::gfloat

Width of the actor (in pixels). If written, forces the minimum and
natural size request of the actor to the given width. If read, returns
the allocated width if available, otherwise the width request.

The Clutter::Actor:width property is animatable.

Returns:

  • (Clutter::gfloat) —

    width

#width=(width) ⇒ Clutter::gfloat

Width of the actor (in pixels). If written, forces the minimum and
natural size request of the actor to the given width. If read, returns
the allocated width if available, otherwise the width request.

The Clutter::Actor:width property is animatable.

Parameters:

  • width (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    width

  • (Clutter::gfloat) —

    width

#x ⇒ Clutter::gfloat

X coordinate of the actor in pixels. If written, forces a fixed
position for the actor. If read, returns the fixed position if any,
otherwise the allocation if available, otherwise 0.

The Clutter::Actor:x property is animatable.

Returns:

  • (Clutter::gfloat) —

    x

#x=(x) ⇒ Clutter::gfloat

X coordinate of the actor in pixels. If written, forces a fixed
position for the actor. If read, returns the fixed position if any,
otherwise the allocation if available, otherwise 0.

The Clutter::Actor:x property is animatable.

Parameters:

  • x (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    x

  • (Clutter::gfloat) —

    x

#x_align ⇒ Clutter::ActorAlign

The alignment of an actor on the X axis, if the actor has been given
extra space for its allocation. See also the Clutter::Actor:x-expand
property.

Returns:

#x_align=(x_align) ⇒ Clutter::ActorAlign

The alignment of an actor on the X axis, if the actor has been given
extra space for its allocation. See also the Clutter::Actor:x-expand
property.

Parameters:

Returns:

#x_expand ⇒ Boolean

Retrieves the value set with clutter_actor_set_x_expand().

See also: clutter_actor_needs_expand()

Returns:

  • (Boolean) —

    true if the actor has been set to expand

#x_expand=(x_expand) ⇒ Boolean

Whether a layout manager should assign more space to the actor on
the X axis.

Parameters:

  • x_expand (Boolean)

Returns:

  • (Boolean) —

    x-expand

  • (Boolean) —

    x-expand

#x_expand? ⇒ Boolean

Whether a layout manager should assign more space to the actor on
the X axis.

Returns:

  • (Boolean) —

    x-expand

#y ⇒ Clutter::gfloat

Y coordinate of the actor in pixels. If written, forces a fixed
position for the actor. If read, returns the fixed position if
any, otherwise the allocation if available, otherwise 0.

The Clutter::Actor:y property is animatable.

Returns:

  • (Clutter::gfloat) —

    y

#y=(y) ⇒ Clutter::gfloat

Y coordinate of the actor in pixels. If written, forces a fixed
position for the actor. If read, returns the fixed position if
any, otherwise the allocation if available, otherwise 0.

The Clutter::Actor:y property is animatable.

Parameters:

  • y (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    y

  • (Clutter::gfloat) —

    y

#y_align ⇒ Clutter::ActorAlign

The alignment of an actor on the Y axis, if the actor has been given
extra space for its allocation.

Returns:

#y_align=(y_align) ⇒ Clutter::ActorAlign

The alignment of an actor on the Y axis, if the actor has been given
extra space for its allocation.

Parameters:

Returns:

#y_expand ⇒ Boolean

Retrieves the value set with clutter_actor_set_y_expand().

See also: clutter_actor_needs_expand()

Returns:

  • (Boolean) —

    true if the actor has been set to expand

#y_expand=(y_expand) ⇒ Boolean

Whether a layout manager should assign more space to the actor on
the Y axis.

Parameters:

  • y_expand (Boolean)

Returns:

  • (Boolean) —

    y-expand

  • (Boolean) —

    y-expand

#y_expand? ⇒ Boolean

Whether a layout manager should assign more space to the actor on
the Y axis.

Returns:

  • (Boolean) —

    y-expand

#z_position ⇒ Clutter::gfloat

The actor's position on the Z axis, relative to the parent's
transformations.

Positive values will bring the actor's position nearer to the user,
whereas negative values will bring the actor's position farther from
the user.

The Clutter::Actor:z-position does not affect the paint or allocation
order.

The Clutter::Actor:z-position property is animatable.

Returns:

  • (Clutter::gfloat) —

    z-position

#z_position=(z_position) ⇒ Clutter::gfloat

The actor's position on the Z axis, relative to the parent's
transformations.

Positive values will bring the actor's position nearer to the user,
whereas negative values will bring the actor's position farther from
the user.

The Clutter::Actor:z-position does not affect the paint or allocation
order.

The Clutter::Actor:z-position property is animatable.

Parameters:

  • z_position (Clutter::gfloat)

Returns:

  • (Clutter::gfloat) —

    z-position

  • (Clutter::gfloat) —

    z-position

#z_rotation_gravity ⇒ Clutter::Gravity

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: