
@c %start of fragment

@deffn Function clutter-actor-new  @result{}@tie{} (ret@tie{}@code{<clutter-actor>})
Creates a new @code{<clutter-actor>}.

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

@table @var
@item ret
the newly created @code{<clutter-actor>}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-flags  (self@tie{}@code{<clutter-actor>}) (flags@tie{}@code{<clutter-actor-flags>})
@deffnx Method set-flags
Sets @var{flags} on @var{self}

This function will emit notifications for the changed properties

@table @var
@item self
a @code{<clutter-actor>}

@item flags
the flags to set

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-unset-flags  (self@tie{}@code{<clutter-actor>}) (flags@tie{}@code{<clutter-actor-flags>})
@deffnx Method unset-flags
Unsets @var{flags} on @var{self}

This function will emit notifications for the changed properties

@table @var
@item self
a @code{<clutter-actor>}

@item flags
the flags to unset

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-get-flags  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor-flags>})
@deffnx Method get-flags
Retrieves the flags set on @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a bitwise or of @code{<clutter-actor-flags>} or 0

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-set-name  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars})
@deffnx Method set-name
Sets the given name to @var{self}. The name can be used to identify a
@code{<clutter-actor>}.

@table @var
@item self
A @code{<clutter-actor>}

@item name
Textual tag to apply to actor

@end table

@end deffn

@deffn Function clutter-actor-get-name  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{mchars})
@deffnx Method get-name
Retrieves the name of @var{self}.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
the name of the actor, or @samp{@code{#f}}. The returned string is owned
by the actor and should not be modified or freed.

@end table

@end deffn

@deffn Function clutter-actor-show  (self@tie{}@code{<clutter-actor>})
@deffnx Method show
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
@code{<"show-on-set-parent">} will be set to @samp{@code{#t}} as a side
effect.

@table @var
@item self
A @code{<clutter-actor>}

@end table

@end deffn

@deffn Function clutter-actor-hide  (self@tie{}@code{<clutter-actor>})
@deffnx Method hide
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
@code{<"show-on-set-parent">} property will be set to @samp{@code{#f}}
as a side-effect.

@table @var
@item self
A @code{<clutter-actor>}

@end table

@end deffn

@deffn Function clutter-actor-realize  (self@tie{}@code{<clutter-actor>})
@deffnx Method realize
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
@code{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.

@table @var
@item self
A @code{<clutter-actor>}

@end table

@end deffn

@deffn Function clutter-actor-unrealize  (self@tie{}@code{<clutter-actor>})
@deffnx Method unrealize
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.

@table @var
@item self
A @code{<clutter-actor>}

@end table

@end deffn

@deffn Function clutter-actor-paint  (self@tie{}@code{<clutter-actor>})
@deffnx Method paint
Renders the actor to display.

This function should not be called directly by applications. Call
@code{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 @code{<"paint">} signal or the
@code{<"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.

@table @var
@item self
A @code{<clutter-actor>}

@end table

@end deffn

@deffn Function clutter-actor-continue-paint  (self@tie{}@code{<clutter-actor>})
@deffnx Method continue-paint
Run the next stage of the paint sequence. This function should only be
called within the implementation of the ‘run’ virtual of a
@code{<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.

@table @var
@item self
A @code{<clutter-actor>}

@end table

Since 1.8

@end deffn

@deffn Function clutter-actor-queue-redraw  (self@tie{}@code{<clutter-actor>})
@deffnx Method queue-redraw
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 @var{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.

@table @var
@item self
A @code{<clutter-actor>}

@end table

@end deffn

@deffn Function clutter-actor-queue-relayout  (self@tie{}@code{<clutter-actor>})
@deffnx Method queue-relayout
Indicates that the actor's size request or other layout-affecting
properties may have changed. This function is used inside
@code{<clutter-actor>} subclass implementations, not by applications
directly.

Queueing a new layout automatically queues a redraw as well.

@table @var
@item self
A @code{<clutter-actor>}

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-destroy  (self@tie{}@code{<clutter-actor>})
@deffnx Method destroy
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 @code{<clutter-stage>} returned by
@code{clutter-stage-get-default}.

@table @var
@item self
a @code{<clutter-actor>}

@end table

@end deffn

@deffn Function clutter-actor-event  (self@tie{}@code{<clutter-actor>}) (event@tie{}@code{<clutter-event>}) (capture@tie{}@code{bool}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method event
This function is used to emit an event on the main stage. You should
rarely need to use this function, except for synthetising events.

@table @var
@item actor
a @code{<clutter-actor>}

@item event
a @code{<clutter-event>}

@item capture
TRUE if event in in capture phase, FALSE otherwise.

@item ret
the return value from the signal emission: @samp{@code{#t}} if the actor
handled the event, or @samp{@code{#f}} if the event was not handled

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-should-pick-paint  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method should-pick-paint
Should be called inside the implementation of the @code{<"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.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor should paint its silhouette,
@samp{@code{#f}} otherwise

@end table

@end deffn

@deffn Function clutter-actor-map  (self@tie{}@code{<clutter-actor>})
@deffnx Method map
Sets the @samp{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 @code{clutter-actor-class.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.

@table @var
@item self
A @code{<clutter-actor>}

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-unmap  (self@tie{}@code{<clutter-actor>})
@deffnx Method unmap
Unsets the @samp{CLUTTER_ACTOR_MAPPED} flag on the actor and possibly
unmaps its children if they were mapped.

Calling this function is not encouraged: the default
@code{<clutter-actor>} implementation of
@code{clutter-actor-class.unmap} will also unmap any eventual children
by default when their parent is unmapped.

When overriding @code{clutter-actor-class.unmap}, it is mandatory to
chain up to the parent implementation.

@cartouche 
It is important to note that the implementation of the
@code{clutter-actor-class.unmap} virtual function may be called after
the @code{clutter-actor-class.destroy} or the @code{g-object-class.dispose}
implementation, but it is guaranteed to be called before the
@code{g-object-class.finalize} implementation.
@end cartouche

@table @var
@item self
A @code{<clutter-actor>}

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-has-overlaps  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method has-overlaps
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
@code{<clutter-actor>}@code{has-overlaps} virtual function. See
@code{clutter-actor-set-offscreen-redirect} for more information.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor may have overlapping primitives, and
@samp{@code{#f}} otherwise

@end table

Since 1.8

@end deffn

@deffn Function clutter-actor-allocate  (self@tie{}@code{<clutter-actor>}) (box@tie{}@code{<clutter-actor-box>}) (flags@tie{}@code{<clutter-allocation-flags>})
@deffnx Method allocate
Called by the parent of an actor to assign the actor its size. Should
never be called by applications (except when implementing a container or
layout manager).

Actors can know from their allocation box whether they have moved with
respect to their parent actor. The @var{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.

@table @var
@item self
A @code{<clutter-actor>}

@item box
new allocation of the actor, in parent-relative coordinates

@item flags
flags that control the allocation

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-allocate-align-fill  (self@tie{}@code{<clutter-actor>}) (box@tie{}@code{<clutter-actor-box>}) (x_align@tie{}@code{double}) (y_align@tie{}@code{double}) (x_fill@tie{}@code{bool}) (y_fill@tie{}@code{bool}) (flags@tie{}@code{<clutter-allocation-flags>})
@deffnx Method allocate-align-fill
Allocates @var{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 @var{box} should contain the available allocation width and height;
if the x1 and y1 members of @code{<clutter-actor-box>} are not set to 0,
the allocation will be offset by their value.

This function takes into consideration the geometry request specified by
the @code{<"request-mode">} property, and the text direction.

This function is useful for fluid layout managers, like
@code{<clutter-bin-layout>} or @code{<clutter-table-layout>}

@table @var
@item self
a @code{<clutter-actor>}

@item box
a @code{<clutter-actor-box>}, containing the available width and height

@item x-align
the horizontal alignment, between 0 and 1

@item y-align
the vertical alignment, between 0 and 1

@item x-fill
whether the actor should fill horizontally

@item y-fill
whether the actor should fill vertically

@item flags
allocation flags to be passed to @code{clutter-actor-allocate}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-set-allocation  (self@tie{}@code{<clutter-actor>}) (box@tie{}@code{<clutter-actor-box>}) (flags@tie{}@code{<clutter-allocation-flags>})
@deffnx Method set-allocation
Stores the allocation of @var{self} as defined by @var{box}.

This function can only be called from within the implementation of the
@code{clutter-actor-class.allocate} virtual function.

The allocation should have been adjusted to take into account
constraints, alignment, and margin properties. If you are implementing a
@code{<clutter-actor>} subclass that provides its own layout management
policy for its children instead of using a
@code{<clutter-layout-manager>} delegate, you should not call this
function on the children of @var{self}; instead, you should call
@code{clutter-actor-allocate}, which will adjust the allocation box for
you.

This function should only be used by subclasses of
@code{<clutter-actor>} that wish to store their allocation but cannot
chain up to the parent's implementation; the default implementation of
the @code{clutter-actor-class.allocate} virtual function will call this
function.

It is important to note that, while chaining up was the recommended
behaviour for @code{<clutter-actor>} subclasses prior to the
introduction of this function, it is recommended to call
@code{clutter-actor-set-allocation} instead.

If the @code{<clutter-actor>} is using a @code{<clutter-layout-manager>}
delegate object to handle the allocation of its children, this function
will call the @code{clutter-layout-manager-allocate} function only if
the @samp{CLUTTER_DELEGATE_LAYOUT} flag is set on @var{flags}, otherwise
it is expected that the subclass will call
@code{clutter-layout-manager-allocate} by itself. For instance, the
following code:

@example 

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

  adjust_allocation (allocation, &new_alloc);

  new_flags = flags | CLUTTER_DELEGATE_LAYOUT;

  /&#x002A; this will use the layout manager set on the actor &#x002A;/
  clutter_actor_set_allocation (actor, &new_alloc, new_flags);
@}
@end example

is equivalent to this:

@example 

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);
@}
@end example

@table @var
@item self
a @code{<clutter-actor>}

@item box
a @code{<clutter-actor-box>}

@item flags
allocation flags

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-allocation-box  (self@tie{}@code{<clutter-actor>}) (box@tie{}@code{<clutter-actor-box>})
@deffnx Method get-allocation-box
Gets the layout box an actor has been assigned. The allocation can only
be assumed valid inside a @code{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.

@cartouche 
Do not call any of the clutter_actor_get_allocation_*() family
of functions inside the implementation of the @code{get-preferred-width}
or @code{get-preferred-height} virtual functions.
@end cartouche

@table @var
@item self
A @code{<clutter-actor>}

@item box
the function fills this in with the actor's allocation.

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-get-preferred-size  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (min_width_p@tie{}@code{float}) (min_height_p@tie{}@code{float}) (natural_width_p@tie{}@code{float}) (natural_height_p@tie{}@code{float})
@deffnx Method get-preferred-size
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
@code{clutter-actor-get-preferred-width} and
@code{clutter-actor-get-preferred-height}, and check the actor's
preferred geometry management using the @code{<"request-mode">}
property.

@table @var
@item self
a @code{<clutter-actor>}

@item min-width-p
return location for the minimum width, or @samp{@code{#f}}.

@item min-height-p
return location for the minimum height, or @samp{@code{#f}}.

@item natural-width-p
return location for the natural width, or @samp{@code{#f}}.

@item natural-height-p
return location for the natural height, or @samp{@code{#f}}.

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-get-preferred-width  (self@tie{}@code{<clutter-actor>}) (for_height@tie{}@code{float}) @result{}@tie{} (min_width_p@tie{}@code{float}) (natural_width_p@tie{}@code{float})
@deffnx Method get-preferred-width
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.

@table @var
@item self
A @code{<clutter-actor>}

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

@item min-width-p
return location for minimum width, or @samp{@code{#f}}.

@item natural-width-p
return location for the natural width, or @samp{@code{#f}}.

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-get-preferred-height  (self@tie{}@code{<clutter-actor>}) (for_width@tie{}@code{float}) @result{}@tie{} (min_height_p@tie{}@code{float}) (natural_height_p@tie{}@code{float})
@deffnx Method get-preferred-height
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.

@table @var
@item self
A @code{<clutter-actor>}

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

@item min-height-p
return location for minimum height, or @samp{@code{#f}}.

@item natural-height-p
return location for natural height, or @samp{@code{#f}}.

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-set-request-mode  (self@tie{}@code{<clutter-actor>}) (mode@tie{}@code{<clutter-request-mode>})
@deffnx Method set-request-mode
Sets the geometry request mode of @var{self}.

The @var{mode} determines the order for invoking
@code{clutter-actor-get-preferred-width} and
@code{clutter-actor-get-preferred-height}

@table @var
@item self
a @code{<clutter-actor>}

@item mode
the request mode

@end table

Since 1.2

@end deffn

@deffn Function clutter-actor-get-request-mode  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-request-mode>})
@deffnx Method get-request-mode
Retrieves the geometry request mode of @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the request mode for the actor

@end table

Since 1.2

@end deffn

@deffn Function clutter-actor-has-allocation  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method has-allocation
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 @samp{@code{#f}}, then the actor will normally
be allocated before it is next drawn on the screen.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor has an up-to-date allocation

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-set-x-align  (self@tie{}@code{<clutter-actor>}) (x_align@tie{}@code{<clutter-actor-align>})
@deffnx Method set-x-align
Sets the horizontal alignment policy of a @code{<clutter-actor>}, in
case the actor received extra horizontal space.

See also the @code{<"x-align">} property.

@table @var
@item self
a @code{<clutter-actor>}

@item x-align
the horizontal alignment policy

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-x-align  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor-align>})
@deffnx Method get-x-align
Retrieves the horizontal alignment policy set using
@code{clutter-actor-set-x-align}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the horizontal alignment policy.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-y-align  (self@tie{}@code{<clutter-actor>}) (y_align@tie{}@code{<clutter-actor-align>})
@deffnx Method set-y-align
Sets the vertical alignment policy of a @code{<clutter-actor>}, in case
the actor received extra vertical space.

See also the @code{<"y-align">} property.

@table @var
@item self
a @code{<clutter-actor>}

@item y-align
the vertical alignment policy

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-y-align  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor-align>})
@deffnx Method get-y-align
Retrieves the vertical alignment policy set using
@code{clutter-actor-set-y-align}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the vertical alignment policy.

@end table

Since 1.10

@end deffn

@deffn Function clutter-margin-new  @result{}@tie{} (ret@tie{}@code{<clutter-margin>})
Creates a new @code{<clutter-margin>}.

@table @var
@item ret
a newly allocated @code{<clutter-margin>}. Use
@code{clutter-margin-free} to free the resources associated with it when
done.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-margin  (self@tie{}@code{<clutter-actor>}) (margin@tie{}@code{<clutter-margin>})
@deffnx Method set-margin
Sets all the components of the margin of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item margin
a @code{<clutter-margin>}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-margin  (self@tie{}@code{<clutter-actor>}) (margin@tie{}@code{<clutter-margin>})
@deffnx Method get-margin
Retrieves all the components of the margin of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item margin
return location for a @code{<clutter-margin>}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-margin-top  (self@tie{}@code{<clutter-actor>}) (margin@tie{}@code{float})
@deffnx Method set-margin-top
Sets the margin from the top of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item margin
the top margin

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-margin-top  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-margin-top
Retrieves the top margin of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the top margin

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-margin-right  (self@tie{}@code{<clutter-actor>}) (margin@tie{}@code{float})
@deffnx Method set-margin-right
Sets the margin from the right of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item margin
the right margin

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-margin-right  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-margin-right
Retrieves the right margin of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the right margin

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-margin-bottom  (self@tie{}@code{<clutter-actor>}) (margin@tie{}@code{float})
@deffnx Method set-margin-bottom
Sets the margin from the bottom of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item margin
the bottom margin

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-margin-bottom  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-margin-bottom
Retrieves the bottom margin of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the bottom margin

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-margin-left  (self@tie{}@code{<clutter-actor>}) (margin@tie{}@code{float})
@deffnx Method set-margin-left
Sets the margin from the left of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item margin
the left margin

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-margin-left  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-margin-left
Retrieves the left margin of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the left margin

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-layout-manager  (self@tie{}@code{<clutter-actor>}) (manager@tie{}@code{<clutter-layout-manager>})
@deffnx Method set-layout-manager
Sets the @code{<clutter-layout-manager>} delegate object that will be
used to lay out the children of @var{self}.

The @code{<clutter-actor>} will take a reference on the passed
@var{manager} which will be released either when the layout manager is
removed, or when the actor is destroyed.

@table @var
@item self
a @code{<clutter-actor>}

@item manager
a @code{<clutter-layout-manager>}, or @samp{@code{#f}} to unset it.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-layout-manager  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-layout-manager>})
@deffnx Method get-layout-manager
Retrieves the @code{<clutter-layout-manager>} used by @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a pointer to the @code{<clutter-layout-manager>}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-background-color  (self@tie{}@code{<clutter-actor>}) (color@tie{}@code{<clutter-color>})
@deffnx Method set-background-color
Sets the background color of a @code{<clutter-actor>}.

The background color will be used to cover the whole allocation of the
actor. The default background color of an actor is transparent.

To check whether an actor has a background color, you can use the
@code{<"background-color-set">} actor property.

The @code{<"background-color">} property is animatable.

@table @var
@item self
a @code{<clutter-actor>}

@item color
a @code{<clutter-color>}, or @samp{@code{#f}} to unset a previously set
color.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-background-color  (self@tie{}@code{<clutter-actor>}) (color@tie{}@code{<clutter-color>})
@deffnx Method get-background-color
Retrieves the color set using @code{clutter-actor-set-background-color}.

@table @var
@item self
a @code{<clutter-actor>}

@item color
return location for a @code{<clutter-color>}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-size  (self@tie{}@code{<clutter-actor>}) (width@tie{}@code{float}) (height@tie{}@code{float})
@deffnx Method set-size
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 @var{width} and/or @var{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.

@table @var
@item self
A @code{<clutter-actor>}

@item width
New width of actor in pixels, or -1

@item height
New height of actor in pixels, or -1

@end table

@end deffn

@deffn Function clutter-actor-get-size  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (width@tie{}@code{float}) (height@tie{}@code{float})
@deffnx Method get-size
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
@code{clutter-actor-get-allocation-box} or
@code{clutter-actor-get-preferred-width}.

@table @var
@item self
A @code{<clutter-actor>}

@item width
return location for the width, or @samp{@code{#f}}.

@item height
return location for the height, or @samp{@code{#f}}.

@end table

Since 0.2

@end deffn

@deffn Function clutter-actor-set-position  (self@tie{}@code{<clutter-actor>}) (x@tie{}@code{float}) (y@tie{}@code{float})
@deffnx Method set-position
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.

@table @var
@item self
A @code{<clutter-actor>}

@item x
New left position of actor in pixels.

@item y
New top position of actor in pixels.

@end table

@end deffn

@deffn Function clutter-actor-get-position  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (x@tie{}@code{float}) (y@tie{}@code{float})
@deffnx Method get-position
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.

@table @var
@item self
a @code{<clutter-actor>}

@item x
return location for the X coordinate, or @samp{@code{#f}}.

@item y
return location for the Y coordinate, or @samp{@code{#f}}.

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-set-width  (self@tie{}@code{<clutter-actor>}) (width@tie{}@code{float})
@deffnx Method set-width
Forces a width on an actor, causing the actor's preferred width and
height (if any) to be ignored.

If @var{width} is -1 the actor will use its preferred width request
instead of overriding it, i.e. you can "unset" the width with -1.

This function sets both the minimum and natural size of the actor.

@table @var
@item self
A @code{<clutter-actor>}

@item width
Requested new width for the actor, in pixels, or -1

@end table

Since 0.2

@end deffn

@deffn Function clutter-actor-get-width  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-width
Retrieves the width of a @code{<clutter-actor>}.

If the actor has a valid allocation, this function will return the width
of the allocated area given to the actor.

If the actor does not have a valid allocation, this function will return
the actor's natural width, that is the preferred width of the actor.

If you care whether you get the preferred width or the width that has
been assigned to the actor, you should probably call a different
function like @code{clutter-actor-get-allocation-box} to retrieve the
allocated size or @code{clutter-actor-get-preferred-width} to retrieve
the preferred width.

If an actor has a fixed width, for instance a width that has been
assigned using @code{clutter-actor-set-width}, the width returned will
be the same value.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
the width of the actor, in pixels

@end table

@end deffn

@deffn Function clutter-actor-set-height  (self@tie{}@code{<clutter-actor>}) (height@tie{}@code{float})
@deffnx Method set-height
Forces a height on an actor, causing the actor's preferred width and
height (if any) to be ignored.

If @var{height} is -1 the actor will use its preferred height instead of
overriding it, i.e. you can "unset" the height with -1.

This function sets both the minimum and natural size of the actor.

@table @var
@item self
A @code{<clutter-actor>}

@item height
Requested new height for the actor, in pixels, or -1

@end table

Since 0.2

@end deffn

@deffn Function clutter-actor-get-height  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-height
Retrieves the height of a @code{<clutter-actor>}.

If the actor has a valid allocation, this function will return the
height of the allocated area given to the actor.

If the actor does not have a valid allocation, this function will return
the actor's natural height, that is the preferred height of the actor.

If you care whether you get the preferred height or the height that has
been assigned to the actor, you should probably call a different
function like @code{clutter-actor-get-allocation-box} to retrieve the
allocated size or @code{clutter-actor-get-preferred-height} to retrieve
the preferred height.

If an actor has a fixed height, for instance a height that has been
assigned using @code{clutter-actor-set-height}, the height returned will
be the same value.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
the height of the actor, in pixels

@end table

@end deffn

@deffn Function clutter-actor-set-x  (self@tie{}@code{<clutter-actor>}) (x@tie{}@code{float})
@deffnx Method set-x
Sets the actor's X coordinate, relative to its parent, in pixels.

Overrides any layout manager and forces a fixed position for the actor.

The @code{<"x">} property is animatable.

@table @var
@item self
a @code{<clutter-actor>}

@item x
the actor's position on the X axis

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-get-x  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-x
Retrieves the X coordinate of a @code{<clutter-actor>}.

This function tries to "do what you mean", by returning the correct
value depending on the actor's state.

If the actor has a valid allocation, this function will return the X
coordinate of the origin of the allocation box.

If the actor has any fixed coordinate set using
@code{clutter-actor-set-x}, @code{clutter-actor-set-position} or
@code{clutter-actor-set-geometry}, this function will return that
coordinate.

If both the allocation and a fixed position are missing, this function
will return 0.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
the X coordinate, in pixels, ignoring any transformation (i.e. scaling,
rotation)

@end table

@end deffn

@deffn Function clutter-actor-set-y  (self@tie{}@code{<clutter-actor>}) (y@tie{}@code{float})
@deffnx Method set-y
Sets the actor's Y coordinate, relative to its parent, in pixels.#

Overrides any layout manager and forces a fixed position for the actor.

The @code{<"y">} property is animatable.

@table @var
@item self
a @code{<clutter-actor>}

@item y
the actor's position on the Y axis

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-get-y  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-y
Retrieves the Y coordinate of a @code{<clutter-actor>}.

This function tries to "do what you mean", by returning the correct
value depending on the actor's state.

If the actor has a valid allocation, this function will return the Y
coordinate of the origin of the allocation box.

If the actor has any fixed coordinate set using
@code{clutter-actor-set-y}, @code{clutter-actor-set-position} or
@code{clutter-actor-set-geometry}, this function will return that
coordinate.

If both the allocation and a fixed position are missing, this function
will return 0.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
the Y coordinate, in pixels, ignoring any transformation (i.e. scaling,
rotation)

@end table

@end deffn

@deffn Function clutter-actor-move-by  (self@tie{}@code{<clutter-actor>}) (dx@tie{}@code{float}) (dy@tie{}@code{float})
@deffnx Method move-by
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 @code{clutter-actor-set-anchor-point}.

@table @var
@item self
A @code{<clutter-actor>}

@item dx
Distance to move Actor on X axis.

@item dy
Distance to move Actor on Y axis.

@end table

Since 0.2

@end deffn

@deffn Function clutter-actor-set-depth  (self@tie{}@code{<clutter-actor>}) (depth@tie{}@code{float})
@deffnx Method set-depth
Sets the Z coordinate of @var{self} to @var{depth}.

The unit used by @var{depth} is dependant on the perspective setup. See
also @code{clutter-stage-set-perspective}.

@table @var
@item self
a @code{<clutter-actor>}

@item depth
Z co-ord

@end table

@end deffn

@deffn Function clutter-actor-get-depth  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{float})
@deffnx Method get-depth
Retrieves the depth of @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the depth of the actor

@end table

@end deffn

@deffn Function clutter-actor-set-scale  (self@tie{}@code{<clutter-actor>}) (scale_x@tie{}@code{double}) (scale_y@tie{}@code{double})
@deffnx Method set-scale
Scales an actor with the given factors. The scaling is relative to the
scale center and the anchor point. The scale center is unchanged by this
function and defaults to 0,0.

The @code{<"scale-x">} and @code{<"scale-y">} properties are animatable.

@table @var
@item self
A @code{<clutter-actor>}

@item scale-x
double factor to scale actor by horizontally.

@item scale-y
double factor to scale actor by vertically.

@end table

Since 0.2

@end deffn

@deffn Function clutter-actor-set-scale-full  (self@tie{}@code{<clutter-actor>}) (scale_x@tie{}@code{double}) (scale_y@tie{}@code{double}) (center_x@tie{}@code{float}) (center_y@tie{}@code{float})
@deffnx Method set-scale-full
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 @code{<"scale-x">} and @code{<"scale-y">} properties are animatable.

@table @var
@item self
A @code{<clutter-actor>}

@item scale-x
double factor to scale actor by horizontally.

@item scale-y
double factor to scale actor by vertically.

@item center-x
X coordinate of the center of the scale.

@item center-y
Y coordinate of the center of the scale

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-get-scale  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (scale_x@tie{}@code{double}) (scale_y@tie{}@code{double})
@deffnx Method get-scale
Retrieves an actors scale factors.

@table @var
@item self
A @code{<clutter-actor>}

@item scale-x
Location to store horizonal scale factor, or @samp{@code{#f}}.

@item scale-y
Location to store vertical scale factor, or @samp{@code{#f}}.

@end table

Since 0.2

@end deffn

@deffn Function clutter-actor-get-scale-center  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (center_x@tie{}@code{float}) (center_y@tie{}@code{float})
@deffnx Method get-scale-center
Retrieves the scale center coordinate in pixels relative to the top left
corner of the actor. If the scale center was specified using a
@code{<clutter-gravity>} this will calculate the pixel offset using the
current size of the actor.

@table @var
@item self
A @code{<clutter-actor>}

@item center-x
Location to store the X position of the scale center, or
@samp{@code{#f}}.

@item center-y
Location to store the Y position of the scale center, or
@samp{@code{#f}}.

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-get-scale-gravity  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-gravity>})
@deffnx Method get-scale-gravity
Retrieves the scale center as a compass direction. If the scale center
was specified in pixels or units this will return
@samp{CLUTTER_GRAVITY_NONE}.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
the scale gravity

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-is-scaled  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method is-scaled
Checks whether the actor is scaled in either dimension.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor is scaled.

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-set-rotation  (self@tie{}@code{<clutter-actor>}) (axis@tie{}@code{<clutter-rotate-axis>}) (angle@tie{}@code{double}) (x@tie{}@code{float}) (y@tie{}@code{float}) (z@tie{}@code{float})
@deffnx Method set-rotation
Sets the rotation angle of @var{self} around the given axis.

The rotation center coordinates used depend on the value of @var{axis}:

@itemize 
@item
@item
@item
@end itemize

@samp{CLUTTER_X_AXIS} requires @var{y} and @var{z}

@samp{CLUTTER_Y_AXIS} requires @var{x} and @var{z}

@samp{CLUTTER_Z_AXIS} requires @var{x} and @var{y}

The rotation coordinates are relative to the anchor point of the actor,
set using @code{clutter-actor-set-anchor-point}. If no anchor point is
set, the upper left corner is assumed as the origin.

@table @var
@item self
a @code{<clutter-actor>}

@item axis
the axis of rotation

@item angle
the angle of rotation

@item x
X coordinate of the rotation center

@item y
Y coordinate of the rotation center

@item z
Z coordinate of the rotation center

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-get-rotation  (self@tie{}@code{<clutter-actor>}) (axis@tie{}@code{<clutter-rotate-axis>}) @result{}@tie{} (ret@tie{}@code{double}) (x@tie{}@code{float}) (y@tie{}@code{float}) (z@tie{}@code{float})
@deffnx Method get-rotation
Retrieves the angle and center of rotation on the given axis, set using
@code{clutter-actor-set-rotation}.

@table @var
@item self
a @code{<clutter-actor>}

@item axis
the axis of rotation

@item x
return value for the X coordinate of the center of rotation.

@item y
return value for the Y coordinate of the center of rotation.

@item z
return value for the Z coordinate of the center of rotation.

@item ret
the angle of rotation

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-is-rotated  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method is-rotated
Checks whether any rotation is applied to the actor.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor is rotated.

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-set-anchor-point  (self@tie{}@code{<clutter-actor>}) (anchor_x@tie{}@code{float}) (anchor_y@tie{}@code{float})
@deffnx Method set-anchor-point
Sets an anchor point for @var{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.

@table @var
@item self
a @code{<clutter-actor>}

@item anchor-x
X coordinate of the anchor point

@item anchor-y
Y coordinate of the anchor point

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-get-anchor-point  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (anchor_x@tie{}@code{float}) (anchor_y@tie{}@code{float})
@deffnx Method get-anchor-point
Gets the current anchor point of the @var{actor} in pixels.

@table @var
@item self
a @code{<clutter-actor>}

@item anchor-x
return location for the X coordinate of the anchor point.

@item anchor-y
return location for the Y coordinate of the anchor point.

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-move-anchor-point  (self@tie{}@code{<clutter-actor>}) (anchor_x@tie{}@code{float}) (anchor_y@tie{}@code{float})
@deffnx Method move-anchor-point
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.

@table @var
@item self
a @code{<clutter-actor>}

@item anchor-x
X coordinate of the anchor point

@item anchor-y
Y coordinate of the anchor point

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-transform-stage-point  (self@tie{}@code{<clutter-actor>}) (x@tie{}@code{float}) (y@tie{}@code{float}) @result{}@tie{} (ret@tie{}@code{bool}) (x_out@tie{}@code{float}) (y_out@tie{}@code{float})
@deffnx Method transform-stage-point
This function translates screen coordinates (@var{x}, @var{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 @code{paint}.

@table @var
@item self
A @code{<clutter-actor>}

@item x
x screen coordinate of the point to unproject.

@item y
y screen coordinate of the point to unproject.

@item x-out
return location for the unprojected x coordinance.

@item y-out
return location for the unprojected y coordinance.

@item ret
@samp{@code{#t}} if conversion was successful.

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-get-transformed-size  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (width@tie{}@code{float}) (height@tie{}@code{float})
@deffnx Method get-transformed-size
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
@code{clutter-actor-get-abs-allocation-vertices} instead.

@cartouche 
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 @code{clutter-actor-get-transformed-position}; if you need this
information, you need to use @code{clutter-actor-get-abs-allocation-vertices}
to get the coords of the actual quadrangle.
@end cartouche

@table @var
@item self
A @code{<clutter-actor>}

@item width
return location for the width, or @samp{@code{#f}}.

@item height
return location for the height, or @samp{@code{#f}}.

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-get-paint-opacity  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{unsigned-int8})
@deffnx Method get-paint-opacity
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.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
The actor opacity value.

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-get-paint-visibility  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method get-paint-visibility
Retrieves the 'paint' visibility of an actor recursively checking for
non visible parents.

This is by definition the same as @samp{CLUTTER_ACTOR_IS_MAPPED}.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor is visibile and will be painted.

@end table

Since 0.8.4

@end deffn

@deffn Function clutter-actor-get-paint-box  (self@tie{}@code{<clutter-actor>}) (box@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method get-paint-box
Retrieves the paint volume of the passed @code{<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.

@table @var
@item self
a @code{<clutter-actor>}

@item box
return location for a @code{<clutter-actor-box>}.

@item ret
@samp{@code{#t}} if a 2D paint box could be determined, else
@samp{@code{#f}}.

@end table

Since 1.6

@end deffn

@deffn Function clutter-actor-set-content  (self@tie{}@code{<clutter-actor>}) (content@tie{}@code{<clutter-content>})
@deffnx Method set-content
Sets the contents of a @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item content
a @code{<clutter-content>}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-content  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-content>})
@deffnx Method get-content
Retrieves the contents of @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a pointer to the @code{<clutter-content>} instance, or @samp{@code{#f}}
if none was set.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-content-gravity  (self@tie{}@code{<clutter-actor>}) (gravity@tie{}@code{<clutter-content-gravity>})
@deffnx Method set-content-gravity
Sets the gravity of the @code{<clutter-content>} used by @var{self}.

See the description of the @code{<"content-gravity">} property for more
information.

The @code{<"content-gravity">} property is animatable.

@table @var
@item self
a @code{<clutter-actor>}

@item gravity
the @code{<clutter-content-gravity>}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-content-gravity  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-content-gravity>})
@deffnx Method get-content-gravity
Retrieves the content gravity as set using
@code{clutter-actor-get-content-gravity}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the content gravity

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-content-box  (self@tie{}@code{<clutter-actor>}) (box@tie{}@code{<clutter-actor-box>})
@deffnx Method get-content-box
Retrieves the bounding box for the @code{<clutter-content>} of
@var{self}.

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

If no @code{<clutter-content>} is set for @var{self}, or if @var{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 @code{<clutter-actor>}.

If the @code{<clutter-content>} used by the actor has a preferred size,
then it is possible to modify the content box by using the
@code{<"content-gravity">} property.

@table @var
@item self
a @code{<clutter-actor>}

@item box
the return location for the bounding box for the
@code{<clutter-content>}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-clip  (self@tie{}@code{<clutter-actor>}) (xoff@tie{}@code{float}) (yoff@tie{}@code{float}) (width@tie{}@code{float}) (height@tie{}@code{float})
@deffnx Method set-clip
Sets clip area for @var{self}. The clip area is always computed from the
upper left corner of the actor, even if the anchor point is set
otherwise.

@table @var
@item self
A @code{<clutter-actor>}

@item xoff
X offset of the clip rectangle

@item yoff
Y offset of the clip rectangle

@item width
Width of the clip rectangle

@item height
Height of the clip rectangle

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-remove-clip  (self@tie{}@code{<clutter-actor>})
@deffnx Method remove-clip
Removes clip area from @var{self}.

@table @var
@item self
A @code{<clutter-actor>}

@end table

@end deffn

@deffn Function clutter-actor-has-clip  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method has-clip
Determines whether the actor has a clip area set or not.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor has a clip area set.

@end table

Since 0.1.1

@end deffn

@deffn Function clutter-actor-get-clip  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (xoff@tie{}@code{float}) (yoff@tie{}@code{float}) (width@tie{}@code{float}) (height@tie{}@code{float})
@deffnx Method get-clip
Gets the clip area for @var{self}, if any is set

@table @var
@item self
a @code{<clutter-actor>}

@item xoff
return location for the X offset of the clip rectangle, or
@samp{@code{#f}}.

@item yoff
return location for the Y offset of the clip rectangle, or
@samp{@code{#f}}.

@item width
return location for the width of the clip rectangle, or
@samp{@code{#f}}.

@item height
return location for the height of the clip rectangle, or
@samp{@code{#f}}.

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-set-opacity  (self@tie{}@code{<clutter-actor>}) (opacity@tie{}@code{unsigned-int8})
@deffnx Method set-opacity
Sets the actor's opacity, with zero being completely transparent and 255
(0xff) being fully opaque.

The @code{<"opacity">} property is animatable.

@table @var
@item self
A @code{<clutter-actor>}

@item opacity
New opacity value for the actor.

@end table

@end deffn

@deffn Function clutter-actor-get-opacity  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{unsigned-int8})
@deffnx Method get-opacity
Retrieves the opacity value of an actor, as set by
@code{clutter-actor-set-opacity}.

For retrieving the absolute opacity of the actor inside a paint virtual
function, see @code{clutter-actor-get-paint-opacity}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the opacity of the actor

@end table

@end deffn

@deffn Function clutter-actor-is-in-clone-paint  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method is-in-clone-paint
Checks whether @var{self} is being currently painted by a
@code{<clutter-clone>}

This function is useful only inside the ::paint virtual function
implementations or within handlers for the @code{<"paint">} signal

This function should not be used by applications

@table @var
@item self
a @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the @code{<clutter-actor>} is currently being
painted by a @code{<clutter-clone>}, and @samp{@code{#f}} otherwise

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-add-child  (self@tie{}@code{<clutter-actor>}) (child@tie{}@code{<clutter-actor>})
@deffnx Method add-child
Adds @var{child} to the children of @var{self}.

This function will acquire a reference on @var{child} that will only be
released when calling @code{clutter-actor-remove-child}.

This function will take into consideration the @code{<"depth">} of
@var{child}, and will keep the list of children sorted.

This function will emit the @code{<"actor-added">} signal on @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item child
a @code{<clutter-actor>}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-insert-child-above  (self@tie{}@code{<clutter-actor>}) (child@tie{}@code{<clutter-actor>}) (sibling@tie{}@code{<clutter-actor>})
@deffnx Method insert-child-above
Inserts @var{child} into the list of children of @var{self}, above
another child of @var{self} or, if @var{sibling} is @samp{@code{#f}},
above all the children of @var{self}.

This function will acquire a reference on @var{child} that will only be
released when calling @code{clutter-actor-remove-child}.

This function will not take into consideration the @code{<"depth">} of
@var{child}.

This function will emit the @code{<"actor-added">} signal on @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item child
a @code{<clutter-actor>}

@item sibling
a child of @var{self}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-insert-child-at-index  (self@tie{}@code{<clutter-actor>}) (child@tie{}@code{<clutter-actor>}) (index_@tie{}@code{int})
@deffnx Method insert-child-at-index
Inserts @var{child} into the list of children of @var{self}, using the
given @var{index}. If @var{index} is greater than the number of children
in @var{self}, or is less than 0, then the new child is added at the
end.

This function will acquire a reference on @var{child} that will only be
released when calling @code{clutter-actor-remove-child}.

This function will not take into consideration the @code{<"depth">} of
@var{child}.

This function will emit the @code{<"actor-added">} signal on @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item child
a @code{<clutter-actor>}

@item index
the index

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-insert-child-below  (self@tie{}@code{<clutter-actor>}) (child@tie{}@code{<clutter-actor>}) (sibling@tie{}@code{<clutter-actor>})
@deffnx Method insert-child-below
Inserts @var{child} into the list of children of @var{self}, below
another child of @var{self} or, if @var{sibling} is @samp{@code{#f}},
below all the children of @var{self}.

This function will acquire a reference on @var{child} that will only be
released when calling @code{clutter-actor-remove-child}.

This function will not take into consideration the @code{<"depth">} of
@var{child}.

This function will emit the @code{<"actor-added">} signal on @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item child
a @code{<clutter-actor>}

@item sibling
a child of @var{self}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-replace-child  (self@tie{}@code{<clutter-actor>}) (old_child@tie{}@code{<clutter-actor>}) (new_child@tie{}@code{<clutter-actor>})
@deffnx Method replace-child
Replaces @var{old-child} with @var{new-child} in the list of children of
@var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item old-child
the child of @var{self} to replace

@item new-child
the @code{<clutter-actor>} to replace @var{old-child}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-remove-child  (self@tie{}@code{<clutter-actor>}) (child@tie{}@code{<clutter-actor>})
@deffnx Method remove-child
Removes @var{child} from the children of @var{self}.

This function will release the reference added by
@code{clutter-actor-add-child}, so if you want to keep using @var{child}
you will have to acquire a referenced on it before calling this
function.

This function will emit the @code{<"actor-removed">} signal on
@var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item child
a @code{<clutter-actor>}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-remove-all-children  (self@tie{}@code{<clutter-actor>})
@deffnx Method remove-all-children
Removes all children of @var{self}.

This function releases the reference added by inserting a child actor in
the list of children of @var{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
@var{self}, use @code{clutter-actor-destroy-all-children}.

@table @var
@item self
a @code{<clutter-actor>}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-destroy-all-children  (self@tie{}@code{<clutter-actor>})
@deffnx Method destroy-all-children
Destroys all children of @var{self}.

This function releases the reference added by inserting a child actor in
the list of children of @var{self}, and ensures that the
@code{<"destroy">} signal is emitted on each child of the actor.

By default, @code{<clutter-actor>} will emit the @code{<"destroy">}
signal when its reference count drops to 0; the default handler of the
@code{<"destroy">} signal will destroy all the children of an actor.
This function ensures that all children are destroyed, instead of just
removed from @var{self}, unlike @code{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 @var{self}
prior to calling @code{clutter-actor-remove-all-children} and want to
reuse the actors, you should use
@code{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.

@table @var
@item self
a @code{<clutter-actor>}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-first-child  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor>})
@deffnx Method get-first-child
Retrieves the first child of @var{self}.

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

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a pointer to a @code{<clutter-actor>}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-next-sibling  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor>})
@deffnx Method get-next-sibling
Retrieves the sibling of @var{self} that comes after it in the list of
children of @var{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 @var{self} while iterating
it.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a pointer to a @code{<clutter-actor>}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-previous-sibling  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor>})
@deffnx Method get-previous-sibling
Retrieves the sibling of @var{self} that comes before it in the list of
children of @var{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 @var{self} while iterating
it.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a pointer to a @code{<clutter-actor>}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-last-child  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor>})
@deffnx Method get-last-child
Retrieves the last child of @var{self}.

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

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a pointer to a @code{<clutter-actor>}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-child-at-index  (self@tie{}@code{<clutter-actor>}) (index_@tie{}@code{int}) @result{}@tie{} (ret@tie{}@code{<clutter-actor>})
@deffnx Method get-child-at-index
Retrieves the actor at the given @var{index} inside the list of children
of @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item index
the position in the list of children

@item ret
a pointer to a @code{<clutter-actor>}, or @samp{@code{#f}}.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-children  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{glist-of})
@deffnx Method get-children
Retrieves the list of children of @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
A newly allocated @code{<g-list>} of @code{<clutter-actor>}s. Use
@code{g-list-free} when done.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-n-children  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{int})
@deffnx Method get-n-children
Retrieves the number of children of @var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the number of children of an actor

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-parent  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor>})
@deffnx Method get-parent
Retrieves the parent of @var{self}.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
The @code{<clutter-actor>} parent, or @samp{@code{#f}} if no parent is
set.

@end table

@end deffn

@deffn Function clutter-actor-set-child-at-index  (self@tie{}@code{<clutter-actor>}) (child@tie{}@code{<clutter-actor>}) (index_@tie{}@code{int})
@deffnx Method set-child-at-index
Changes the index of @var{child} in the list of children of @var{self}.

This function is logically equivalent to removing @var{child} and
calling @code{clutter-actor-insert-child-at-index}, but it will not emit
signals or change state on @var{child}.

@table @var
@item self
a @code{<clutter-actor>}

@item child
a @code{<clutter-actor>} child of @var{self}

@item index
the new index for @var{child}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-contains  (self@tie{}@code{<clutter-actor>}) (descendant@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method contains
Determines if @var{descendant} is contained inside @var{self} (either as
an immediate child, or as a deeper descendant). If @var{self} and
@var{descendant} point to the same actor then it will also return
@samp{@code{#t}}.

@table @var
@item self
A @code{<clutter-actor>}

@item descendant
A @code{<clutter-actor>}, possibly contained in @var{self}

@item ret
whether @var{descendent} is contained within @var{self}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-get-stage  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-actor>})
@deffnx Method get-stage
Retrieves the @code{<clutter-stage>} where @var{actor} is contained.

@table @var
@item actor
a @code{<clutter-actor>}

@item ret
the stage containing the actor, or @samp{@code{#f}}.

@end table

Since 0.8

@end deffn

@deffn Function clutter-actor-save-easing-state  (self@tie{}@code{<clutter-actor>})
@deffnx Method save-easing-state
Saves the current easing state for animatable properties, and creates a
new state with the default values for easing mode and duration.

@table @var
@item self
a @code{<clutter-actor>}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-restore-easing-state  (self@tie{}@code{<clutter-actor>})
@deffnx Method restore-easing-state
Restores the easing state as it was prior to a call to
@code{clutter-actor-save-easing-state}.

@table @var
@item self
a @code{<clutter-actor>}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-easing-duration  (self@tie{}@code{<clutter-actor>}) (msecs@tie{}@code{unsigned-int})
@deffnx Method set-easing-duration
Sets the duration of the tweening for animatable properties of
@var{self} for the current easing state.

@table @var
@item self
a @code{<clutter-actor>}

@item msecs
the duration of the easing, or @samp{@code{#f}}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-easing-duration  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{unsigned-int})
@deffnx Method get-easing-duration
Retrieves the duration of the tweening for animatable properties of
@var{self} for the current easing state.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the duration of the tweening, in milliseconds

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-easing-mode  (self@tie{}@code{<clutter-actor>}) (mode@tie{}@code{<clutter-animation-mode>})
@deffnx Method set-easing-mode
Sets the easing mode for the tweening of animatable properties of
@var{self}.

@table @var
@item self
a @code{<clutter-actor>}

@item mode
an easing mode, excluding @samp{CLUTTER_CUSTOM_MODE}

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-easing-mode  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-animation-mode>})
@deffnx Method get-easing-mode
Retrieves the easing mode for the tweening of animatable properties of
@var{self} for the current easing state.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
an easing mode

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-easing-delay  (self@tie{}@code{<clutter-actor>}) (msecs@tie{}@code{unsigned-int})
@deffnx Method set-easing-delay
Sets the delay that should be applied before tweening animatable
properties.

@table @var
@item self
a @code{<clutter-actor>}

@item msecs
the delay before the start of the tweening, in milliseconds

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-easing-delay  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{unsigned-int})
@deffnx Method get-easing-delay
Retrieves the delay that should be applied when tweening animatable
properties.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a delay, in milliseconds

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-transition  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars}) @result{}@tie{} (ret@tie{}@code{<clutter-transition>})
@deffnx Method get-transition
Retrieves the @code{<clutter-transition>} of a @code{<clutter-actor>} by
using the transition @var{name}.

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

@example 

  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, "completed",
                    G_CALLBACK (on_transition_complete),
                    actor);
@end example

will call the @code{on-transition-complete} callback when the transition
is complete.

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name of the transition

@item ret
a @code{<clutter-transition>}, or @samp{@code{#f}} is none was found to
match the passed name; the returned instance is owned by Clutter and it
should not be freed.

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-add-transition  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars}) (transition@tie{}@code{<clutter-transition>})
@deffnx Method add-transition
Adds a @var{transition} to the @code{<clutter-actor>}'s list of
animations.

The @var{name} string is a per-actor unique identifier of the
@var{transition}: only one @code{<clutter-transition>} can be associated
to the specified @var{name}.

The @var{transition} will be given the easing duration, mode, and delay
associated to the actor's current easing state; it is possible to modify
these values after calling @code{clutter-actor-add-transition}.

The @var{transition} will be started once added.

This function will take a reference on the @var{transition}.

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

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name of the transition to add

@item transition
the @code{<clutter-transition>} to add

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-remove-transition  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars})
@deffnx Method remove-transition
Removes the transition stored inside a @code{<clutter-actor>} using
@var{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 @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name of the transition to remove

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-set-reactive  (self@tie{}@code{<clutter-actor>}) (reactive@tie{}@code{bool})
@deffnx Method set-reactive
Sets @var{actor} as reactive. Reactive actors will receive events.

@table @var
@item actor
a @code{<clutter-actor>}

@item reactive
whether the actor should be reactive to events

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-get-reactive  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method get-reactive
Checks whether @var{actor} is marked as reactive.

@table @var
@item actor
a @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor is reactive

@end table

Since 0.6

@end deffn

@deffn Function clutter-actor-has-key-focus  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method has-key-focus
Checks whether @var{self} is the @code{<clutter-actor>} that has key
focus

@table @var
@item self
a @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor has key focus, and @samp{@code{#f}}
otherwise

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-grab-key-focus  (self@tie{}@code{<clutter-actor>})
@deffnx Method grab-key-focus
Sets the key focus of the @code{<clutter-stage>} including @var{self} to
this @code{<clutter-actor>}.

@table @var
@item self
a @code{<clutter-actor>}

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-has-pointer  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method has-pointer
Checks whether an actor contains the pointer of a
@code{<clutter-input-device>}

@table @var
@item self
a @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor contains the pointer, and @samp{@code{#f}}
otherwise

@end table

Since 1.2

@end deffn

@deffn Function clutter-actor-get-pango-context  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<pango-context>})
@deffnx Method get-pango-context
Retrieves the @code{<pango-context>} for @var{self}. The actor's
@code{<pango-context>} is already configured using the appropriate font
map, resolution and font options.

Unlike @code{clutter-actor-create-pango-context}, this context is owend
by the @code{<clutter-actor>} and it will be updated each time the
options stored by the @code{<clutter-backend>} change.

You can use the returned @code{<pango-context>} to create a
@code{<pango-layout>} and render text using
@code{cogl-pango-render-layout} to reuse the glyphs cache also used by
Clutter.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the @code{<pango-context>} for a @code{<clutter-actor>}. The returned
@code{<pango-context>} is owned by the actor and should not be
unreferenced by the application code.

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-create-pango-context  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<pango-context>})
@deffnx Method create-pango-context
Creates a @code{<pango-context>} for the given actor. The
@code{<pango-context>} is already configured using the appropriate font
map, resolution and font options.

See also @code{clutter-actor-get-pango-context}.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the newly created @code{<pango-context>}. Use @code{g-object-unref} on
the returned value to deallocate its resources.

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-create-pango-layout  (self@tie{}@code{<clutter-actor>}) (text@tie{}@code{mchars}) @result{}@tie{} (ret@tie{}@code{<pango-layout>})
@deffnx Method create-pango-layout
Creates a new @code{<pango-layout>} from the same @code{<pango-context>}
used by the @code{<clutter-actor>}. The @code{<pango-layout>} is already
configured with the font map, resolution and font options, and the given
@var{text}.

If you want to keep around a @code{<pango-layout>} created by this
function you will have to connect to the @code{<"font-changed">} and
@code{<"resolution-changed">} signals, and call
@code{pango-layout-context-changed} in response to them.

@table @var
@item self
a @code{<clutter-actor>}

@item text
(allow-none) the text to set on the @code{<pango-layout>}, or
@samp{@code{#f}}

@item ret
the newly created @code{<pango-layout>}. Use @code{g-object-unref} when
done.

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-set-text-direction  (self@tie{}@code{<clutter-actor>}) (text_dir@tie{}@code{<clutter-text-direction>})
@deffnx Method set-text-direction
Sets the @code{<clutter-text-direction>} for an actor

The passed text direction must not be
@samp{CLUTTER_TEXT_DIRECTION_DEFAULT}

If @var{self} implements @code{<clutter-container>} then this function
will recurse inside all the children of @var{self} (including the
internal ones).

Composite actors not implementing @code{<clutter-container>}, or actors
requiring special handling when the text direction changes, should
connect to the @code{<"notify">} signal for the
@code{<"text-direction">} property

@table @var
@item self
a @code{<clutter-actor>}

@item text-dir
the text direction for @var{self}

@end table

Since 1.2

@end deffn

@deffn Function clutter-actor-get-text-direction  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<clutter-text-direction>})
@deffnx Method get-text-direction
Retrieves the value set using @code{clutter-actor-set-text-direction}

If no text direction has been previously set, the default text
direction, as returned by @code{clutter-get-default-text-direction},
will be returned instead

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the @code{<clutter-text-direction>} for the actor

@end table

Since 1.2

@end deffn

@deffn Function clutter-actor-get-accessible  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{<atk-object>})
@deffnx Method get-accessible
Returns the accessible object that describes the actor to an assistive
technology.

If no class-specific @code{<atk-object>} implementation is available for
the actor instance in question, it will inherit an @code{<atk-object>}
implementation from the first ancestor class for which such an
implementation is defined.

The documentation of the
@uref{http://developer.gnome.org/doc/API/2.0/atk/index.html,ATK} library
contains more information about accessible objects and their uses.

@table @var
@item self
a @code{<clutter-actor>}

@item ret
the @code{<atk-object>} associated with @var{actor}.

@end table

@end deffn

@deffn Function clutter-actor-add-action  (self@tie{}@code{<clutter-actor>}) (action@tie{}@code{<clutter-action>})
@deffnx Method add-action
Adds @var{action} to the list of actions applied to @var{self}

A @code{<clutter-action>} can only belong to one actor at a time

The @code{<clutter-actor>} will hold a reference on @var{action} until
either @code{clutter-actor-remove-action} or
@code{clutter-actor-clear-actions} is called

@table @var
@item self
a @code{<clutter-actor>}

@item action
a @code{<clutter-action>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-add-action-with-name  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars}) (action@tie{}@code{<clutter-action>})
@deffnx Method add-action-with-name
A convenience function for setting the name of a @code{<clutter-action>}
while adding it to the list of actions applied to @var{self}

This function is the logical equivalent of:

@example 

  clutter_actor_meta_set_name (CLUTTER_ACTOR_META (action), name);
  clutter_actor_add_action (self, action);
@end example

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name to set on the action

@item action
a @code{<clutter-action>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-remove-action  (self@tie{}@code{<clutter-actor>}) (action@tie{}@code{<clutter-action>})
@deffnx Method remove-action
Removes @var{action} from the list of actions applied to @var{self}

The reference held by @var{self} on the @code{<clutter-action>} will be
released

@table @var
@item self
a @code{<clutter-actor>}

@item action
a @code{<clutter-action>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-remove-action-by-name  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars})
@deffnx Method remove-action-by-name
Removes the @code{<clutter-action>} with the given name from the list of
actions applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name of the action to remove

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-has-actions  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method has-actions
Returns whether the actor has any actions applied.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor has any actions, @samp{@code{#f}}
otherwise

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-actions  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{glist-of})
@deffnx Method get-actions
Retrieves the list of actions applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a copy of the list of @code{<clutter-action>}s. The contents of the list
are owned by the @code{<clutter-actor>}. Use @code{g-list-free} to free
the resources allocated by the returned @code{<g-list>}.

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-get-action  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars}) @result{}@tie{} (ret@tie{}@code{<clutter-action>})
@deffnx Method get-action
Retrieves the @code{<clutter-action>} with the given name in the list of
actions applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name of the action to retrieve

@item ret
a @code{<clutter-action>} for the given name, or @samp{@code{#f}}. The
returned @code{<clutter-action>} is owned by the actor and it should not
be unreferenced directly.

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-clear-actions  (self@tie{}@code{<clutter-actor>})
@deffnx Method clear-actions
Clears the list of actions applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-add-constraint  (self@tie{}@code{<clutter-actor>}) (constraint@tie{}@code{<clutter-constraint>})
@deffnx Method add-constraint
Adds @var{constraint} to the list of @code{<clutter-constraint>}s
applied to @var{self}

The @code{<clutter-actor>} will hold a reference on the @var{constraint}
until either @code{clutter-actor-remove-constraint} or
@code{clutter-actor-clear-constraints} is called.

@table @var
@item self
a @code{<clutter-actor>}

@item constraint
a @code{<clutter-constraint>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-remove-constraint  (self@tie{}@code{<clutter-actor>}) (constraint@tie{}@code{<clutter-constraint>})
@deffnx Method remove-constraint
Removes @var{constraint} from the list of constraints applied to
@var{self}

The reference held by @var{self} on the @code{<clutter-constraint>} will
be released

@table @var
@item self
a @code{<clutter-actor>}

@item constraint
a @code{<clutter-constraint>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-has-constraints  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method has-constraints
Returns whether the actor has any constraints applied.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor has any constraints, @samp{@code{#f}}
otherwise

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-constraints  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{glist-of})
@deffnx Method get-constraints
Retrieves the list of constraints applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a copy of the list of @code{<clutter-constraint>}s. The contents of the
list are owned by the @code{<clutter-actor>}. Use @code{g-list-free} to
free the resources allocated by the returned @code{<g-list>}.

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-get-constraint  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars}) @result{}@tie{} (ret@tie{}@code{<clutter-constraint>})
@deffnx Method get-constraint
Retrieves the @code{<clutter-constraint>} with the given name in the
list of constraints applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name of the constraint to retrieve

@item ret
a @code{<clutter-constraint>} for the given name, or @samp{@code{#f}}.
The returned @code{<clutter-constraint>} is owned by the actor and it
should not be unreferenced directly.

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-clear-constraints  (self@tie{}@code{<clutter-actor>})
@deffnx Method clear-constraints
Clears the list of constraints applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-add-effect  (self@tie{}@code{<clutter-actor>}) (effect@tie{}@code{<clutter-effect>})
@deffnx Method add-effect
Adds @var{effect} to the list of @code{<clutter-effect>}s applied to
@var{self}

The @code{<clutter-actor>} will hold a reference on the @var{effect}
until either @code{clutter-actor-remove-effect} or
@code{clutter-actor-clear-effects} is called.

@table @var
@item self
a @code{<clutter-actor>}

@item effect
a @code{<clutter-effect>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-add-effect-with-name  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars}) (effect@tie{}@code{<clutter-effect>})
@deffnx Method add-effect-with-name
A convenience function for setting the name of a @code{<clutter-effect>}
while adding it to the list of effectss applied to @var{self}

This function is the logical equivalent of:

@example 

  clutter_actor_meta_set_name (CLUTTER_ACTOR_META (effect), name);
  clutter_actor_add_effect (self, effect);
@end example

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name to set on the effect

@item effect
a @code{<clutter-effect>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-remove-effect  (self@tie{}@code{<clutter-actor>}) (effect@tie{}@code{<clutter-effect>})
@deffnx Method remove-effect
Removes @var{effect} from the list of effects applied to @var{self}

The reference held by @var{self} on the @code{<clutter-effect>} will be
released

@table @var
@item self
a @code{<clutter-actor>}

@item effect
a @code{<clutter-effect>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-remove-effect-by-name  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars})
@deffnx Method remove-effect-by-name
Removes the @code{<clutter-effect>} with the given name from the list of
effects applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name of the effect to remove

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-has-effects  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{bool})
@deffnx Method has-effects
Returns whether the actor has any effects applied.

@table @var
@item self
A @code{<clutter-actor>}

@item ret
@samp{@code{#t}} if the actor has any effects, @samp{@code{#f}}
otherwise

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-get-effects  (self@tie{}@code{<clutter-actor>}) @result{}@tie{} (ret@tie{}@code{glist-of})
@deffnx Method get-effects
Retrieves the @code{<clutter-effect>}s applied on @var{self}, if any

@table @var
@item self
a @code{<clutter-actor>}

@item ret
a list of @code{<clutter-effect>}s, or @samp{@code{#f}}. The elements of
the returned list are owned by Clutter and they should not be freed. You
should free the returned list using @code{g-list-free} when done.

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-get-effect  (self@tie{}@code{<clutter-actor>}) (name@tie{}@code{mchars}) @result{}@tie{} (ret@tie{}@code{<clutter-effect>})
@deffnx Method get-effect
Retrieves the @code{<clutter-effect>} with the given name in the list of
effects applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@item name
the name of the effect to retrieve

@item ret
a @code{<clutter-effect>} for the given name, or @samp{@code{#f}}. The
returned @code{<clutter-effect>} is owned by the actor and it should not
be unreferenced directly.

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-clear-effects  (self@tie{}@code{<clutter-actor>})
@deffnx Method clear-effects
Clears the list of effects applied to @var{self}

@table @var
@item self
a @code{<clutter-actor>}

@end table

Since 1.4

@end deffn

@deffn Function clutter-actor-box-new  (x_1@tie{}@code{float}) (y_1@tie{}@code{float}) (x_2@tie{}@code{float}) (y_2@tie{}@code{float}) @result{}@tie{} (ret@tie{}@code{<clutter-actor-box>})
Allocates a new @code{<clutter-actor-box>} using the passed coordinates
for the top left and bottom right points

@table @var
@item x-1
X coordinate of the top left point

@item y-1
Y coordinate of the top left point

@item x-2
X coordinate of the bottom right point

@item y-2
Y coordinate of the bottom right point

@item ret
the newly allocated @code{<clutter-actor-box>}. Use
@code{clutter-actor-box-free} to free the resources

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-init  (self@tie{}@code{<clutter-actor-box>}) (x_1@tie{}@code{float}) (y_1@tie{}@code{float}) (x_2@tie{}@code{float}) (y_2@tie{}@code{float})
Initializes @var{box} with the given coordinates.

@table @var
@item box
a @code{<clutter-actor-box>}

@item x-1
X coordinate of the top left point

@item y-1
Y coordinate of the top left point

@item x-2
X coordinate of the bottom right point

@item y-2
Y coordinate of the bottom right point

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-box-init-rect  (self@tie{}@code{<clutter-actor-box>}) (x@tie{}@code{float}) (y@tie{}@code{float}) (width@tie{}@code{float}) (height@tie{}@code{float})
Initializes @var{box} with the given origin and size.

@table @var
@item box
a @code{<clutter-actor-box>}

@item x
X coordinate of the origin

@item y
Y coordinate of the origin

@item width
width of the box

@item height
height of the box

@end table

Since 1.10

@end deffn

@deffn Function clutter-actor-box-equal  (self@tie{}@code{<clutter-actor-box>}) (box_b@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (ret@tie{}@code{bool})
Checks @var{box-a} and @var{box-b} for equality

@table @var
@item box-a
a @code{<clutter-actor-box>}

@item box-b
a @code{<clutter-actor-box>}

@item ret
@samp{@code{#t}} if the passed @code{<clutter-actor-box>} are equal

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-get-x  (self@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (ret@tie{}@code{float})
Retrieves the X coordinate of the origin of @var{box}

@table @var
@item box
a @code{<clutter-actor-box>}

@item ret
the X coordinate of the origin

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-get-y  (self@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (ret@tie{}@code{float})
Retrieves the Y coordinate of the origin of @var{box}

@table @var
@item box
a @code{<clutter-actor-box>}

@item ret
the Y coordinate of the origin

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-get-width  (self@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (ret@tie{}@code{float})
Retrieves the width of the @var{box}

@table @var
@item box
a @code{<clutter-actor-box>}

@item ret
the width of the box

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-get-height  (self@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (ret@tie{}@code{float})
Retrieves the height of the @var{box}

@table @var
@item box
a @code{<clutter-actor-box>}

@item ret
the height of the box

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-set-origin  (self@tie{}@code{<clutter-actor-box>}) (x@tie{}@code{float}) (y@tie{}@code{float})
Changes the origin of @var{box}, maintaining the size of the
@code{<clutter-actor-box>}.

@table @var
@item box
a @code{<clutter-actor-box>}

@item x
the X coordinate of the new origin

@item y
the Y coordinate of the new origin

@end table

Since 1.6

@end deffn

@deffn Function clutter-actor-box-get-origin  (self@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (x@tie{}@code{float}) (y@tie{}@code{float})
Retrieves the origin of @var{box}

@table @var
@item box
a @code{<clutter-actor-box>}

@item x
return location for the X coordinate, or @samp{@code{#f}}.

@item y
return location for the Y coordinate, or @samp{@code{#f}}.

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-set-size  (self@tie{}@code{<clutter-actor-box>}) (width@tie{}@code{float}) (height@tie{}@code{float})
Sets the size of @var{box}, maintaining the origin of the
@code{<clutter-actor-box>}.

@table @var
@item box
a @code{<clutter-actor-box>}

@item width
the new width

@item height
the new height

@end table

Since 1.6

@end deffn

@deffn Function clutter-actor-box-get-size  (self@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (width@tie{}@code{float}) (height@tie{}@code{float})
Retrieves the size of @var{box}

@table @var
@item box
a @code{<clutter-actor-box>}

@item width
return location for the width, or @samp{@code{#f}}.

@item height
return location for the height, or @samp{@code{#f}}.

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-get-area  (self@tie{}@code{<clutter-actor-box>}) @result{}@tie{} (ret@tie{}@code{float})
Retrieves the area of @var{box}

@table @var
@item box
a @code{<clutter-actor-box>}

@item ret
the area of a @code{<clutter-actor-box>}, in pixels

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-contains  (self@tie{}@code{<clutter-actor-box>}) (x@tie{}@code{float}) (y@tie{}@code{float}) @result{}@tie{} (ret@tie{}@code{bool})
Checks whether a point with @var{x}, @var{y} coordinates is contained
withing @var{box}

@table @var
@item box
a @code{<clutter-actor-box>}

@item x
X coordinate of the point

@item y
Y coordinate of the point

@item ret
@samp{@code{#t}} if the point is contained by the
@code{<clutter-actor-box>}

@end table

Since 1.0

@end deffn

@deffn Function clutter-actor-box-clamp-to-pixel  (self@tie{}@code{<clutter-actor-box>})
Clamps the components of @var{box} to the nearest integer

@table @var
@item box
the @code{<clutter-actor-box>} to clamp.

@end table

Since 1.2

@end deffn

@deffn Function clutter-actor-box-interpolate  (self@tie{}@code{<clutter-actor-box>}) (final@tie{}@code{<clutter-actor-box>}) (progress@tie{}@code{double}) (result@tie{}@code{<clutter-actor-box>})
Interpolates between @var{initial} and
@var{final}@code{<clutter-actor-box>}es using @var{progress}

@table @var
@item initial
the initial @code{<clutter-actor-box>}

@item final
the final @code{<clutter-actor-box>}

@item progress
the interpolation progress

@item result
return location for the interpolation.

@end table

Since 1.2

@end deffn

@deffn Function clutter-actor-box-union  (self@tie{}@code{<clutter-actor-box>}) (b@tie{}@code{<clutter-actor-box>}) (result@tie{}@code{<clutter-actor-box>})
Unions the two boxes @var{a} and @var{b} and stores the result in
@var{result}.

@table @var
@item a
(in) the first @code{<clutter-actor-box>}

@item b
the second @code{<clutter-actor-box>}.

@item result
the @code{<clutter-actor-box>} representing a union of @var{a} and
@var{b}.

@end table

Since 1.4

@end deffn

@deffn Function clutter-vertex-new  (x@tie{}@code{float}) (y@tie{}@code{float}) (z@tie{}@code{float}) @result{}@tie{} (ret@tie{}@code{<clutter-vertex>})
Creates a new @code{<clutter-vertex>} for the point in 3D space
identified by the 3 coordinates @var{x}, @var{y}, @var{z}

@table @var
@item x
X coordinate

@item y
Y coordinate

@item z
Z coordinate

@item ret
the newly allocate @code{<clutter-vertex>}. Use
@code{clutter-vertex-free} to free the resources

@end table

Since 1.0

@end deffn

@deffn Function clutter-vertex-init  (self@tie{}@code{<clutter-vertex>}) (x@tie{}@code{float}) (y@tie{}@code{float}) (z@tie{}@code{float})
Initializes @var{vertex} with the given coordinates.

@table @var
@item vertex
a @code{<clutter-vertex>}

@item x
X coordinate

@item y
Y coordinate

@item z
Z coordinate

@end table

Since 1.10

@end deffn

@deffn Function clutter-vertex-equal  (self@tie{}@code{<clutter-vertex>}) (vertex_b@tie{}@code{<clutter-vertex>}) @result{}@tie{} (ret@tie{}@code{bool})
Compares @var{vertex-a} and @var{vertex-b} for equality

@table @var
@item vertex-a
a @code{<clutter-vertex>}

@item vertex-b
a @code{<clutter-vertex>}

@item ret
@samp{@code{#t}} if the passed @code{<clutter-vertex>} are equal

@end table

Since 1.0

@end deffn

@deffn Function clutter-geometry-union  (self@tie{}@code{<clutter-geometry>}) (geometry_b@tie{}@code{<clutter-geometry>}) (result@tie{}@code{<clutter-geometry>})
Find the union of two rectangles represented as
@code{<clutter-geometry>}.

@table @var
@item geometry-a
a @code{<clutter-geometry>}

@item geometry-b
another @code{<clutter-geometry>}

@item result
location to store the result.

@end table

Since 1.4

@end deffn

@deffn Function clutter-geometry-intersects  (self@tie{}@code{<clutter-geometry>}) (geometry1@tie{}@code{<clutter-geometry>}) @result{}@tie{} (ret@tie{}@code{bool})
Determines if @var{geometry0} and geometry1 intersect returning
@samp{@code{#t}} if they do else @samp{@code{#f}}.

@table @var
@item geometry0
The first geometry to test

@item geometry1
The second geometry to test

@item ret
@samp{@code{#t}} of @var{geometry0} and geometry1 intersect else
@samp{@code{#f}}.

@end table

Since 1.4

@end deffn

@deffn Function clutter-paint-volume-set-origin  (self@tie{}@code{<clutter-paint-volume>}) (origin@tie{}@code{<clutter-vertex>})
Sets the origin of the paint volume.

The origin is defined as the X, Y and Z coordinates of the top-left
corner of an actor's paint volume, in actor coordinates.

The default is origin is assumed at: (0, 0, 0)

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item origin
a @code{<clutter-vertex>}

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-get-origin  (self@tie{}@code{<clutter-paint-volume>}) (vertex@tie{}@code{<clutter-vertex>})
Retrieves the origin of the @code{<clutter-paint-volume>}.

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item vertex
the return location for a @code{<clutter-vertex>}.

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-set-width  (self@tie{}@code{<clutter-paint-volume>}) (width@tie{}@code{float})
Sets the width of the paint volume. The width is measured along the x
axis in the actor coordinates that @var{pv} is associated with.

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item width
the width of the paint volume, in pixels

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-get-width  (self@tie{}@code{<clutter-paint-volume>}) @result{}@tie{} (ret@tie{}@code{float})
Retrieves the width of the volume's, axis aligned, bounding box.

In other words; this takes into account what actor's coordinate space
@var{pv} belongs too and conceptually fits an axis aligned box around
the volume. It returns the size of that bounding box as measured along
the x-axis.

If, for example, @code{clutter-actor-get-transformed-paint-volume} is
used to transform a 2D child actor that is 100px wide, 100px high and
0px deep into container coordinates then the width might not simply be
100px if the child actor has a 3D rotation applied to it.

Remember; after @code{clutter-actor-get-transformed-paint-volume} is
used then a transformed child volume will be defined relative to the
ancestor container actor and so a 2D child actor can have a 3D bounding
volume.

@cartouche 
There are no accuracy guarantees for the reported width,
except that it must always be >= to the true width. This is
because actors may report simple, loose fitting paint-volumes
for efficiency
@end cartouche

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item ret
the width, in units of @var{pv}'s local coordinate system.

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-set-height  (self@tie{}@code{<clutter-paint-volume>}) (height@tie{}@code{float})
Sets the height of the paint volume. The height is measured along the y
axis in the actor coordinates that @var{pv} is associated with.

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item height
the height of the paint volume, in pixels

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-get-height  (self@tie{}@code{<clutter-paint-volume>}) @result{}@tie{} (ret@tie{}@code{float})
Retrieves the height of the volume's, axis aligned, bounding box.

In other words; this takes into account what actor's coordinate space
@var{pv} belongs too and conceptually fits an axis aligned box around
the volume. It returns the size of that bounding box as measured along
the y-axis.

If, for example, @code{clutter-actor-get-transformed-paint-volume} is
used to transform a 2D child actor that is 100px wide, 100px high and
0px deep into container coordinates then the height might not simply be
100px if the child actor has a 3D rotation applied to it.

Remember; after @code{clutter-actor-get-transformed-paint-volume} is
used then a transformed child volume will be defined relative to the
ancestor container actor and so a 2D child actor can have a 3D bounding
volume.

@cartouche 
There are no accuracy guarantees for the reported height,
except that it must always be >= to the true height. This is
because actors may report simple, loose fitting paint-volumes
for efficiency
@end cartouche

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item ret
the height, in units of @var{pv}'s local coordinate system.

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-set-depth  (self@tie{}@code{<clutter-paint-volume>}) (depth@tie{}@code{float})
Sets the depth of the paint volume. The depth is measured along the z
axis in the actor coordinates that @var{pv} is associated with.

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item depth
the depth of the paint volume, in pixels

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-get-depth  (self@tie{}@code{<clutter-paint-volume>}) @result{}@tie{} (ret@tie{}@code{float})
Retrieves the depth of the volume's, axis aligned, bounding box.

In other words; this takes into account what actor's coordinate space
@var{pv} belongs too and conceptually fits an axis aligned box around
the volume. It returns the size of that bounding box as measured along
the z-axis.

If, for example, @code{clutter-actor-get-transformed-paint-volume} is
used to transform a 2D child actor that is 100px wide, 100px high and
0px deep into container coordinates then the depth might not simply be
0px if the child actor has a 3D rotation applied to it.

Remember; after @code{clutter-actor-get-transformed-paint-volume} is
used then the transformed volume will be defined relative to the
container actor and in container coordinates a 2D child actor can have a
3D bounding volume.

@cartouche 
There are no accuracy guarantees for the reported depth,
except that it must always be >= to the true depth. This is
because actors may report simple, loose fitting paint-volumes
for efficiency.
@end cartouche

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item ret
the depth, in units of @var{pv}'s local coordinate system.

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-union  (self@tie{}@code{<clutter-paint-volume>}) (another_pv@tie{}@code{<clutter-paint-volume>})
Updates the geometry of @var{pv} to encompass @var{pv} and
@var{another-pv}.

@cartouche 
There are no guarantees about how precisely the two volumes
will be encompassed.
@end cartouche

@table @var
@item pv
The first @code{<clutter-paint-volume>} and destination for resulting
union

@item another-pv
A second @code{<clutter-paint-volume>} to union with @var{pv}

@end table

Since 1.6

@end deffn

@deffn Function clutter-paint-volume-union-box  (self@tie{}@code{<clutter-paint-volume>}) (box@tie{}@code{<clutter-actor-box>})
Unions the 2D region represented by @var{box} to a
@code{<clutter-paint-volume>}.

This function is similar to @code{clutter-paint-volume-union}, but it is
specific for 2D regions.

@table @var
@item pv
a @code{<clutter-paint-volume>}

@item box
a @code{<clutter-actor-box>} to union to @var{pv}

@end table

Since 1.10

@end deffn


@c %end of fragment
