The <structname>ClutterAction</structname> structure contains only
private data and should be accessed using the provided API
The <structname>ClutterActionClass</structname> structure contains
only private data
Base class for actors.
Calls clutter_actor_show() on all children of an actor (if any).
Calls clutter_actor_hide() on all child actors (if any).
Sets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly maps
and realizes its children if they are visible. Does nothing if the
actor is not visible.
#ClutterActor <function>map()</function> virtual function in an actor
and you need to map the children of that actor. It is not necessary
to call this if you implement #ClutterContainer because the default
implementation will automatically map children of containers.
When overriding map, it is mandatory to chain up to the parent
implementation.
Unsets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly
unmaps its children if they were mapped.
#ClutterActor <function>unmap()</function> virtual function in an actor
and you need to unmap the children of that actor. It is not necessary
to call this if you implement #ClutterContainer because the default
implementation will automatically unmap children of containers.
When overriding unmap, it is mandatory to chain up to the parent
implementation.
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.
available height when computing the preferred width, or a negative value to indicate that no height is defined
return location for minimum width, or %NULL
return location for the natural width, or %NULL
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.
available width to assume in computing desired height, or a negative value to indicate that no width is defined
return location for minimum height, or %NULL
return location for natural height, or %NULL
Called by the parent of an actor to assign the actor its size.
Should never be called by applications (except when implementing
a container or layout manager).
Actors can know from their allocation box whether they have moved
with respect to their parent actor. The @flags parameter describes
additional information about the allocation, for instance whether
the parent has moved with respect to the stage, for example because
a grandparent's origin has moved.
new allocation of the actor, in parent-relative coordinates
flags that control the allocation
Returns the accessible object that describes the actor to an
assistive technology.
If no class-specific #AtkObject implementation is available for the
actor instance in question, it will inherit an #AtkObject
implementation from the first ancestor class for which such an
implementation is defined.
The documentation of the <ulink
url="http://developer.gnome.org/doc/API/2.0/atk/index.html">ATK</ulink>
library contains more information about accessible objects and
their uses.
the #AtkObject associated with @actor
Adds @action to the list of actions applied to @self
A #ClutterAction can only belong to one actor at a time
The #ClutterActor will hold a reference on @action until either
clutter_actor_remove_action() or clutter_actor_clear_actions()
is called
a #ClutterAction
A convenience function for setting the name of a #ClutterAction
while adding it to the list of actions applied to @self
This function is the logical equivalent of:
|[
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (action), name);
clutter_actor_add_action (self, action);
]|
the name to set on the action
a #ClutterAction
Removes @action from the list of actions applied to @self
The reference held by @self on the #ClutterAction will be released
a #ClutterAction
Removes the #ClutterAction with the given name from the list
of actions applied to @self
the name of the action to remove
Retrieves the #ClutterAction with the given name in the list
of actions applied to @self
name, or %NULL. The returned #ClutterAction is owned by the
actor and it should not be unreferenced directly
a #ClutterAction for the given
the name of the action to retrieve
Retrieves the list of actions applied to @self
of the list of #ClutterAction<!-- -->s. The contents of the list are
owned by the #ClutterActor. Use g_list_free() to free the resources
allocated by the returned #GList
a copy
Clears the list of actions applied to @self
Adds @effect to the list of #ClutterEffect<!-- -->s applied to @self
The #ClutterActor will hold a reference on the @effect until either
clutter_actor_remove_effect() or clutter_actor_clear_effects() is
called.
a #ClutterEffect
A convenience function for setting the name of a #ClutterEffect
while adding it to the list of effectss applied to @self
This function is the logical equivalent of:
|[
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (effect), name);
clutter_actor_add_effect (self, effect);
]|
the name to set on the effect
a #ClutterEffect
Removes @effect from the list of effects applied to @self
The reference held by @self on the #ClutterEffect will be released
a #ClutterEffect
Removes the #ClutterEffect with the given name from the list
of effects applied to @self
the name of the effect to remove
Retrieves the #ClutterEffect<!-- -->s applied on @self, if any
of #ClutterEffect<!-- -->s, or %NULL. The elements of the returned
list are owned by Clutter and they should not be freed. You should
free the returned list using g_list_free() when done
a list
Retrieves the #ClutterEffect with the given name in the list
of effects applied to @self
name, or %NULL. The returned #ClutterEffect is owned by the
actor and it should not be unreferenced directly
a #ClutterEffect for the given
the name of the effect to retrieve
Clears the list of effects applied to @self
Sets @flags on @self
This function will emit notifications for the changed properties
the flags to set
Unsets @flags on @self
This function will emit notifications for the changed properties
the flags to unset
Retrieves the flags set on @self
a bitwise or of #ClutterActorFlags or 0
Flags an actor to be displayed. An actor that isn't shown will not
be rendered on the stage.
Actors are visible by default.
If this function is called on an actor without a parent, the
#ClutterActor:show-on-set-parent will be set to %TRUE as a side
effect.
Calls clutter_actor_show() on all children of an actor (if any).
Flags an actor to be hidden. A hidden actor will not be
rendered on the stage.
Actors are visible by default.
If this function is called on an actor without a parent, the
#ClutterActor:show-on-set-parent property will be set to %FALSE
as a side-effect.
Calls clutter_actor_hide() on all child actors (if any).
Realization informs the actor that it is attached to a stage. It
can use this to allocate resources if it wanted to delay allocation
until it would be rendered. However it is perfectly acceptable for
an actor to create resources before being realized because Clutter
only ever has a single rendering context so that actor is free to
be moved from one stage to another.
This function does nothing if the actor is already realized.
Because a realized actor must have realized parent actors, calling
clutter_actor_realize() will also realize all parents of the actor.
This function does not realize child actors, except in the special
case that realizing the stage, when the stage is visible, will
suddenly map (and thus realize) the children of the stage.
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.
Sets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly maps
and realizes its children if they are visible. Does nothing if the
actor is not visible.
#ClutterActor <function>map()</function> virtual function in an actor
and you need to map the children of that actor. It is not necessary
to call this if you implement #ClutterContainer because the default
implementation will automatically map children of containers.
When overriding map, it is mandatory to chain up to the parent
implementation.
Unsets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly
unmaps its children if they were mapped.
#ClutterActor <function>unmap()</function> virtual function in an actor
and you need to unmap the children of that actor. It is not necessary
to call this if you implement #ClutterContainer because the default
implementation will automatically unmap children of containers.
When overriding unmap, it is mandatory to chain up to the parent
implementation.
Renders the actor to display.
This function should not be called directly by applications.
Call clutter_actor_queue_redraw() to queue paints, instead.
This function is context-aware, and will either cause a
regular paint or a pick paint.
This function will emit the #ClutterActor::paint signal or
the #ClutterActor::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.
Queues up a redraw of an actor and any children. The redraw occurs
once the main loop becomes idle (after the current batch of events
has been processed, roughly).
Applications rarely need to call this, as redraws are handled
automatically by modification functions.
This function will not do anything if @self is not visible, or
if the actor is inside an invisible part of the scenegraph.
Also be aware that painting is a NOP for actors with an opacity of
0
When you are implementing a custom actor you must queue a redraw
whenever some private state changes that will affect painting or
picking of your actor.
Indicates that the actor's size request or other layout-affecting
properties may have changed. This function is used inside #ClutterActor
subclass implementations, not by applications directly.
Queueing a new layout automatically queues a redraw as well.
Destroys an actor. When an actor is destroyed, it will break any
references it holds to other objects. If the actor is inside a
container, the actor will be removed.
When you destroy a container, its children will be destroyed as well.
clutter_stage_get_default().
Sets the geometry request mode of @self.
The @mode determines the order for invoking
clutter_actor_get_preferred_width() and
clutter_actor_get_preferred_height()
the request mode
Retrieves the geometry request mode of @self
the request mode for the actor
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.
available height when computing the preferred width, or a negative value to indicate that no height is defined
return location for minimum width, or %NULL
return location for the natural width, or %NULL
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.
available width to assume in computing desired height, or a negative value to indicate that no width is defined
return location for minimum height, or %NULL
return location for natural height, or %NULL
Computes the preferred minimum and natural size of an actor, taking into
account the actor's geometry management (either height-for-width
or width-for-height).
The width and height used to compute the preferred height and preferred
width are the actor's natural ones.
If you need to control the height for the preferred width, or the width for
the preferred height, you should use clutter_actor_get_preferred_width()
and clutter_actor_get_preferred_height(), and check the actor's preferred
geometry management using the #ClutterActor:request-mode property.
return location for the minimum width, or %NULL
return location for the minimum height, or %NULL
return location for the natural width, or %NULL
return location for the natural height, or %NULL
Called by the parent of an actor to assign the actor its size.
Should never be called by applications (except when implementing
a container or layout manager).
Actors can know from their allocation box whether they have moved
with respect to their parent actor. The @flags parameter describes
additional information about the allocation, for instance whether
the parent has moved with respect to the stage, for example because
a grandparent's origin has moved.
new allocation of the actor, in parent-relative coordinates
flags that control the allocation
Allocates the natural size of @self.
This function is a utility call for #ClutterActor implementations
that allocates the actor's preferred natural size. It can be used
by fixed layout managers (like #ClutterGroup or so called
'composite actors') inside the ClutterActor::allocate
implementation to give each child exactly how much space it
requires.
This function is not meant to be used by applications. It is also
not meant to be used outside the implementation of the
ClutterActor::allocate virtual function.
flags controlling the allocation
Allocates @self taking into account the #ClutterActor<!-- -->'s
preferred size, but limiting it to the maximum available width
and height provided.
This function will do the right thing when dealing with the
actor's request mode.
The implementation of this function is equivalent to:
|[
if (request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
clutter_actor_get_preferred_width (self, available_height,
&min_width,
&natural_width);
width = CLAMP (natural_width, min_width, available_width);
clutter_actor_get_preferred_height (self, width,
&min_height,
&natural_height);
height = CLAMP (natural_height, min_height, available_height);
}
else
{
clutter_actor_get_preferred_height (self, available_width,
&min_height,
&natural_height);
height = CLAMP (natural_height, min_height, available_height);
clutter_actor_get_preferred_width (self, height,
&min_width,
&natural_width);
width = CLAMP (natural_width, min_width, available_width);
}
box.x1 = x; box.y1 = y;
box.x2 = box.x1 + available_width;
box.y2 = box.y1 + available_height;
clutter_actor_allocate (self, &box, flags);
]|
This function can be used by fluid layout managers to allocate
an actor's preferred size without making it bigger than the area
available for the container.
the actor's X coordinate
the actor's Y coordinate
the maximum available width, or -1 to use the actor's natural width
the maximum available height, or -1 to use the actor's natural height
flags controlling the allocation
Allocates @self by taking into consideration the available allocation
area; an alignment factor on either axis; and whether the actor should
fill the allocation on either axis.
The @box should contain the available allocation width and height;
if the x1 and y1 members of #ClutterActorBox are not set to 0, the
allocation will be offset by their value.
This function takes into consideration the geometry request specified by
the #ClutterActor:request-mode property, and the text direction.
This function is useful for fluid layout managers, like #ClutterBinLayout
or #ClutterTableLayout
a #ClutterActorBox, containing the available width and height
the horizontal alignment, between 0 and 1
the vertical alignment, between 0 and 1
whether the actor should fill horizontally
whether the actor should fill vertically
allocation flags to be passed to clutter_actor_allocate()
Gets the layout box an actor has been assigned. The allocation can
only be assumed valid inside a paint() method; anywhere else, it
may be out-of-date.
An allocation does not incorporate the actor's scale or anchor point;
those transformations do not affect layout, only rendering.
<note>Do not call any of the clutter_actor_get_allocation_*() family
of functions inside the implementation of the get_preferred_width()
or get_preferred_height() virtual functions.</note>
the function fills this in with the actor's allocation
Gets the layout box an actor has been assigned. The allocation can
only be assumed valid inside a paint() method; anywhere else, it
may be out-of-date.
An allocation does not incorporate the actor's scale or anchor point;
those transformations do not affect layout, only rendering.
The returned rectangle is in pixels.
allocation geometry in pixels
Calculates the transformed coordinates of the four corners of the
actor in the plane of @ancestor. The returned vertices relate to
the #ClutterActorBox coordinates as follows:
<itemizedlist>
<listitem><para>@verts[0] contains (x1, y1)</para></listitem>
<listitem><para>@verts[1] contains (x2, y1)</para></listitem>
<listitem><para>@verts[2] contains (x1, y2)</para></listitem>
<listitem><para>@verts[3] contains (x2, y2)</para></listitem>
</itemizedlist>
If @ancestor is %NULL the ancestor will be the #ClutterStage. In
this case, the coordinates returned will be the coordinates on
the stage before the projection is applied. This is different from
the behaviour of clutter_actor_get_abs_allocation_vertices().
A #ClutterActor to calculate the vertices against, or %NULL to use the default #ClutterStage
return location for an array of 4 #ClutterVertex in which to store the result.
Sets the actor's fixed position and forces its minimum and natural
size, in pixels. This means the untransformed actor will have the
given geometry. This is the same as calling clutter_actor_set_position()
and clutter_actor_set_size().
A #ClutterGeometry
Gets the size and position of an actor relative to its parent
actor. This is the same as calling clutter_actor_get_position() and
clutter_actor_get_size(). It tries to "do what you mean" and get the
requested size and position if the actor's allocation is invalid.
A location to store actors #ClutterGeometry
This function tries to "do what you mean" and return
the size an actor will have. If the actor has a valid
allocation, the allocation will be returned; otherwise,
the actors natural size request will be returned.
If you care whether you get the request vs. the allocation, you
should probably call a different function like
clutter_actor_get_allocation_box() or
clutter_actor_get_preferred_width().
return location for the width, or %NULL.
return location for the height, or %NULL.
Gets the absolute size of an actor in pixels, taking into account the
scaling factors.
If the actor has a valid allocation, the allocated size will be used.
If the actor has not a valid allocation then the preferred size will
be transformed and returned.
If you want the transformed allocation, see
clutter_actor_get_abs_allocation_vertices() instead.
<note>When the actor (or one of its ancestors) is rotated around the
X or Y axis, it no longer appears as on the stage as a rectangle, but
as a generic quadrangle; in that case this function returns the size
of the smallest rectangle that encapsulates the entire quad. Please
note that in this case no assumptions can be made about the relative
position of this envelope to the absolute position of the actor, as
returned by clutter_actor_get_transformed_position(); if you need this
information, you need to use clutter_actor_get_abs_allocation_vertices()
to get the coords of the actual quadrangle.</note>
return location for the width, or %NULL
return location for the height, or %NULL
This function tries to "do what you mean" and tell you where the
actor is, prior to any transformations. Retrieves the fixed
position of an actor in pixels, if one has been set; otherwise, if
the allocation is valid, returns the actor's allocated position;
otherwise, returns 0,0.
The returned position is in pixels.
return location for the X coordinate, or %NULL
return location for the Y coordinate, or %NULL
Gets the absolute position of an actor, in pixels relative to the stage.
return location for the X coordinate, or %NULL
return location for the Y coordinate, or %NULL
Checks whether an actor has a fixed position set (and will thus be
unaffected by any layout manager).
%TRUE if the fixed position is set on the actor
Sets whether an actor has a fixed position set (and will thus be
unaffected by any layout manager).
whether to use fixed position
Retrieves the width of a #ClutterActor.
If the actor has a valid allocation, this function will return the
width of the allocated area given to the actor.
If the actor does not have a valid allocation, this function will
return the actor's natural width, that is the preferred width of
the actor.
If you care whether you get the preferred width or the width that
has been assigned to the actor, you should probably call a different
function like clutter_actor_get_allocation_box() to retrieve the
allocated size or clutter_actor_get_preferred_width() to retrieve the
preferred width.
If an actor has a fixed width, for instance a width that has been
assigned using clutter_actor_set_width(), the width returned will
be the same value.
the width of the actor, in pixels
Retrieves the height of a #ClutterActor.
If the actor has a valid allocation, this function will return the
height of the allocated area given to the actor.
If the actor does not have a valid allocation, this function will
return the actor's natural height, that is the preferred height of
the actor.
If you care whether you get the preferred height or the height that
has been assigned to the actor, you should probably call a different
function like clutter_actor_get_allocation_box() to retrieve the
allocated size or clutter_actor_get_preferred_height() to retrieve the
preferred height.
If an actor has a fixed height, for instance a height that has been
assigned using clutter_actor_set_height(), the height returned will
be the same value.
the height of the actor, in pixels
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 actor's position on the X axis
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 actor's position on the Y axis
Sets the rotation angle of @self around the given axis.
The rotation center coordinates used depend on the value of @axis:
<itemizedlist>
<listitem><para>%CLUTTER_X_AXIS requires @y and @z</para></listitem>
<listitem><para>%CLUTTER_Y_AXIS requires @x and @z</para></listitem>
<listitem><para>%CLUTTER_Z_AXIS requires @x and @y</para></listitem>
</itemizedlist>
The rotation coordinates are relative to the anchor point of the
actor, set using clutter_actor_set_anchor_point(). If no anchor
point is set, the upper left corner is assumed as the origin.
the axis of rotation
the angle of rotation
X coordinate of the rotation center
Y coordinate of the rotation center
Z coordinate of the rotation center
Sets the rotation angle of @self around the Z axis using the center
point specified as a compass point. For example to rotate such that
the center of the actor remains static you can use
%CLUTTER_GRAVITY_CENTER. If the actor changes size the center point
will move accordingly.
the angle of rotation
the center point of the rotation
Retrieves the angle and center of rotation on the given axis,
set using clutter_actor_set_rotation().
the angle of rotation
the axis of rotation
return value for the X coordinate of the center of rotation
return value for the Y coordinate of the center of rotation
return value for the Z coordinate of the center of rotation
Retrieves the center for the rotation around the Z axis as a
compass direction. If the center was specified in pixels or units
this will return %CLUTTER_GRAVITY_NONE.
the Z rotation center
Sets the actor's opacity, with zero being completely transparent and
255 (0xff) being fully opaque.
New opacity value for the actor.
Retrieves the opacity value of an actor, as set by
clutter_actor_set_opacity().
For retrieving the absolute opacity of the actor inside a paint
virtual function, see clutter_actor_get_paint_opacity().
the opacity of the actor
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.
The actor opacity value.
Retrieves the 'paint' visibility of an actor recursively checking for non
visible parents.
This is by definition the same as CLUTTER_ACTOR_IS_MAPPED().
TRUE if the actor is visibile and will be painted.
Sets the given name to @self. The name can be used to identify
a #ClutterActor.
Textual tag to apply to actor
Retrieves the name of @self.
owned by the actor and should not be modified or freed.
the name of the actor, or %NULL. The returned string is
Retrieves the unique id for @self.
Globally unique value for this object instance.
Sets clip area for @self. The clip area is always computed from the
upper left corner of the actor, even if the anchor point is set
otherwise.
X offset of the clip rectangle
Y offset of the clip rectangle
Width of the clip rectangle
Height of the clip rectangle
Determines whether the actor has a clip area set or not.
%TRUE if the actor has a clip area set.
Gets the clip area for @self, if any is set
return location for the X offset of the clip rectangle, or %NULL
return location for the Y offset of the clip rectangle, or %NULL
return location for the width of the clip rectangle, or %NULL
return location for the height of the clip rectangle, or %NULL
Sets whether @self should be clipped to the same size as its
allocation
%TRUE to apply a clip tracking the allocation
Retrieves the value set using clutter_actor_set_clip_to_allocation()
%TRUE if the #ClutterActor is clipped to its allocation
Sets the parent of @self to @parent. The opposite function is
clutter_actor_unparent().
This function should not be used by applications, but by custom
container actor subclasses.
A new #ClutterActor parent
Retrieves the parent of @self.
if no parent is set
The #ClutterActor parent, or %NULL
This function resets the parent actor of @self. It is
logically equivalent to calling clutter_actor_unparent()
and clutter_actor_set_parent(), but more efficiently
implemented, ensures the child is not finalized
when unparented, and emits the parent-set signal only
one time.
the new #ClutterActor parent
Removes the parent of @self.
This function should not be used in applications. It should be called by
implementations of container actors, to dissociate a child from the
container.
Determines if @descendant is contained inside @self (either as an
immediate child, or as a deeper descendant).
whether @descendent is contained within @self
A #ClutterActor, possibly contained in @self
Retrieves the #ClutterStage where @actor is contained.
the stage containing the actor, or %NULL
Puts @self above @below.
Both actors must have the same parent, and the parent must implement
the #ClutterContainer interface
This function is the equivalent of clutter_container_raise_child().
A #ClutterActor to raise above.
Puts @self below @above.
Both actors must have the same parent, and the parent must implement
the #ClutterContainer interface.
This function is the equivalent of clutter_container_lower_child().
A #ClutterActor to lower below
Raises @self to the top.
This function calls clutter_actor_raise() internally.
Lowers @self to the bottom.
This function calls clutter_actor_lower() internally.
Sets the Z coordinate of @self to @depth.
The unit used by @depth is dependant on the perspective setup. See
also clutter_stage_set_perspective().
Z co-ord
Retrieves the depth of @self.
the depth of the actor
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.
double factor to scale actor by horizontally.
double factor to scale actor by vertically.
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).
double factor to scale actor by horizontally.
double factor to scale actor by vertically.
X coordinate of the center of the scale.
Y coordinate of the center of the scale
Scales an actor with the given factors around the given
center point. The center point is specified as one of the compass
directions in #ClutterGravity. For example, setting it to north
will cause the top of the actor to remain unchanged and the rest of
the actor to expand left, right and downwards.
double factor to scale actor by horizontally.
double factor to scale actor by vertically.
the location of the scale center expressed as a compass direction.
Retrieves an actors scale factors.
Location to store horizonal scale factor, or %NULL.
Location to store vertical scale factor, or %NULL.
Retrieves the scale center coordinate in pixels relative to the top
left corner of the actor. If the scale center was specified using a
#ClutterGravity this will calculate the pixel offset using the
current size of the actor.
Location to store the X position of the scale center, or %NULL.
Location to store the Y position of the scale center, or %NULL.
Retrieves the scale center as a compass direction. If the scale
center was specified in pixels or units this will return
%CLUTTER_GRAVITY_NONE.
the scale gravity
Moves an actor by the specified distance relative to its current
position in pixels.
This function modifies the fixed position of an actor and thus removes
it from any layout management. Another way to move an actor is with an
anchor point, see clutter_actor_set_anchor_point().
Distance to move Actor on X axis.
Distance to move Actor on Y axis.
Sets @actor as reactive. Reactive actors will receive events.
whether the actor should be reactive to events
Checks whether @actor is marked as reactive.
%TRUE if the actor is reactive
This function is used to emit an event on the main stage.
You should rarely need to use this function, except for
synthetising events.
if the actor handled the event, or %FALSE if the event was
not handled
the return value from the signal emission: %TRUE
a #ClutterEvent
TRUE if event in in capture phase, FALSE otherwise.
Sets the #ClutterShader to be used when rendering @self.
If @shader is %NULL it will unset any currently set shader
for the actor.
%TRUE if the shader was successfully applied
a #ClutterShader or %NULL to unset the shader.
Queries the currently set #ClutterShader on @self.
or %NULL if no shader is set.
The currently set #ClutterShader
Sets the value for a named parameter of the shader applied
to @actor.
the name of the parameter
the value of the parameter
Sets the value for a named int parameter of the shader applied to
the name of the parameter
the value of the parameter
Sets the value for a named float parameter of the shader applied
to @actor.
the name of the parameter
the value of the parameter
Sets an anchor point for @self. The anchor point is a point in the
coordinate space of an actor to which the actor position within its
parent is relative; the default is (0, 0), i.e. the top-left corner
of the actor.
X coordinate of the anchor point
Y coordinate of the 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.
X coordinate of the anchor point
Y coordinate of the anchor point
Gets the current anchor point of the @actor in pixels.
return location for the X coordinate of the anchor point
return location for the Y coordinate of the anchor point
Retrieves the anchor position expressed as a #ClutterGravity. If
the anchor point was specified using pixels or units this will
return %CLUTTER_GRAVITY_NONE.
the #ClutterGravity used by the anchor point
Sets an anchor point on the actor, based on the given gravity (this is a
convenience function wrapping clutter_actor_set_anchor_point()).
Since version 1.0 the anchor point will be stored as a gravity so
that if the actor changes size then the anchor point will move. For
example, if you set the anchor point to %CLUTTER_GRAVITY_SOUTH_EAST
and later double the size of the actor, the anchor point will move
to the bottom right.
#ClutterGravity.
Sets an anchor point on the actor based on the given gravity, adjusting the
actor postion so that its relative position within its parent remains
unchanged.
Since version 1.0 the anchor point will be stored as a gravity so
that if the actor changes size then the anchor point will move. For
example, if you set the anchor point to %CLUTTER_GRAVITY_SOUTH_EAST
and later double the size of the actor, the anchor point will move
to the bottom right.
#ClutterGravity.
Checks whether any rotation is applied to the actor.
%TRUE if the actor is rotated.
Checks whether the actor is scaled in either dimension.
%TRUE if the actor is scaled.
Should be called inside the implementation of the
#ClutterActor::pick virtual function in order to check whether
the actor should paint itself in pick mode or not.
This function should never be called directly by applications.
%FALSE otherwise
%TRUE if the actor should paint its silhouette,
Calculates the transformed screen coordinates of the four corners of
the actor; the returned vertices relate to the #ClutterActorBox
coordinates as follows:
<itemizedlist>
<listitem><para>v[0] contains (x1, y1)</para></listitem>
<listitem><para>v[1] contains (x2, y1)</para></listitem>
<listitem><para>v[2] contains (x1, y2)</para></listitem>
<listitem><para>v[3] contains (x2, y2)</para></listitem>
</itemizedlist>
Pointer to a location of an array of 4 #ClutterVertex where to store the result.
Transforms @point in coordinates relative to the actor
into screen-relative coordinates with the current actor
transformation (i.e. scale, rotation, etc)
A point as #ClutterVertex
The translated #ClutterVertex
Transforms @point in coordinates relative to the actor into
ancestor-relative coordinates using the relevant transform
stack (i.e. scale, rotation, etc).
If @ancestor is %NULL the ancestor will be the #ClutterStage. In
this case, the coordinates returned will be the coordinates on
the stage before the projection is applied. This is different from
the behaviour of clutter_actor_apply_transform_to_point().
A #ClutterActor ancestor, or %NULL to use the default #ClutterStage
A point as #ClutterVertex
The translated #ClutterVertex
Sets the key focus of the #ClutterStage including @self
to this #ClutterActor.
Retrieves the #PangoContext for @self. The actor's #PangoContext
is already configured using the appropriate font map, resolution
and font options.
Unlike clutter_actor_create_pango_context(), this context is owend
by the #ClutterActor and it will be updated each time the options
stored by the #ClutterBackend change.
You can use the returned #PangoContext to create a #PangoLayout
and render text using cogl_pango_render_layout() to reuse the
glyphs cache also used by Clutter.
The returned #PangoContext is owned by the actor and should not be
unreferenced by the application code
the #PangoContext for a #ClutterActor.
Creates a #PangoContext for the given actor. The #PangoContext
is already configured using the appropriate font map, resolution
and font options.
See also clutter_actor_get_pango_context().
on the returned value to deallocate its resources
the newly created #PangoContext. Use g_object_unref()
Creates a new #PangoLayout from the same #PangoContext used
by the #ClutterActor. The #PangoLayout is already configured
with the font map, resolution and font options, and the
given @text.
If you want to keep around a #PangoLayout created by this
function you will have to connect to the #ClutterBackend::font-changed
and #ClutterBackend::resolution-changed signals, and call
pango_layout_context_changed() in response to them.
when done
the newly created #PangoLayout. Use g_object_unref()
(allow-none) the text to set on the #PangoLayout, or %NULL
Retrieves the transformations applied to @self
the return location for a #CoglMatrix
Checks whether @self is being currently painted by a #ClutterClone
This function is useful only inside the ::paint virtual function
implementations or within handlers for the #ClutterActor::paint
signal
This function should not be used by applications
by a #ClutterClone, and %FALSE otherwise
%TRUE if the #ClutterActor is currently being painted
Checks whether an actor contains the the pointer of a
#ClutterInputDevice
%FALSE otherwise
%TRUE if the actor contains the pointer, and
Sets the #ClutterTextDirection for an actor
The passed text direction must not be %CLUTTER_TEXT_DIRECTION_DEFAULT
If @self implements #ClutterContainer then this function will recurse
inside all the children of @self (including the internal ones).
Composite actors not implementing #ClutterContainer, or actors requiring
special handling when the text direction changes, should connect to
the #GObject::notify signal for the #ClutterActor:text-direction property
the text direction for @self
Retrieves the value set using clutter_actor_set_text_direction()
If no text direction has been previously set, the default text
direction, as returned by clutter_get_default_text_direction(), will
be returned instead
the #ClutterTextDirection for the actor
Should be used by actors implementing the #ClutterContainer and with
internal children added through clutter_actor_set_parent(), for instance:
|[
static void
my_actor_init (MyActor *self)
{
self->priv = SELF_ACTOR_GET_PRIVATE (self);
clutter_actor_push_internal (CLUTTER_ACTOR (self));
/* calling clutter_actor_set_parent() now will result in
* the internal flag being set on a child of MyActor
*/
/* internal child - a background texture */
self->priv->background_tex = clutter_texture_new ();
clutter_actor_set_parent (self->priv->background_tex,
CLUTTER_ACTOR (self));
/* internal child - a label */
self->priv->label = clutter_text_new ();
clutter_actor_set_parent (self->priv->label,
CLUTTER_ACTOR (self));
clutter_actor_pop_internal (CLUTTER_ACTOR (self));
/* calling clutter_actor_set_parent() now will not result in
* the internal flag being set on a child of MyActor
*/
}
]|
This function will be used by Clutter to toggle an "internal child"
flag whenever clutter_actor_set_parent() is called; internal children
are handled differently by Clutter, specifically when destroying their
parent.
Call clutter_actor_pop_internal() when you finished adding internal
children.
Nested calls to clutter_actor_push_internal() are allowed, but each
one must by followed by a clutter_actor_pop_internal() call.
Disables the effects of clutter_actor_pop_internal()
Checks if the actor has an up-to-date allocation assigned to
visible and has a parent. It also means that there is no
outstanding relayout request in progress for the actor or its
children (There might be other outstanding layout requests in
progress that will cause the actor to get a new allocation
when the stage is laid out, however).
If this function returns %FALSE, then the actor will normally
be allocated before it is next drawn on the screen.
%TRUE if the actor has an up-to-date allocation
Returns the accessible object that describes the actor to an
assistive technology.
If no class-specific #AtkObject implementation is available for the
actor instance in question, it will inherit an #AtkObject
implementation from the first ancestor class for which such an
implementation is defined.
The documentation of the <ulink
url="http://developer.gnome.org/doc/API/2.0/atk/index.html">ATK</ulink>
library contains more information about accessible objects and
their uses.
the #AtkObject associated with @actor
Adds @constraint to the list of #ClutterConstraint<!-- -->s applied
to @self
The #ClutterActor will hold a reference on the @constraint until
either clutter_actor_remove_constraint() or
clutter_actor_clear_constraints() is called.
a #ClutterConstraint
A convenience function for setting the name of a #ClutterConstraint
while adding it to the list of constraints applied to @self
This function is the logical equivalent of:
|[
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), name);
clutter_actor_add_constraint (self, constraint);
]|
the name to set on the constraint
a #ClutterConstraint
Removes @constraint from the list of constraints applied to @self
The reference held by @self on the #ClutterConstraint will be released
a #ClutterConstraint
Removes the #ClutterConstraint with the given name from the list
of constraints applied to @self
the name of the constraint to remove
Retrieves the list of constraints applied to @self
of the list of #ClutterConstraint<!-- -->s. The contents of the list are
owned by the #ClutterActor. Use g_list_free() to free the resources
allocated by the returned #GList
a copy
Retrieves the #ClutterConstraint with the given name in the list
of constraints applied to @self
name, or %NULL. The returned #ClutterConstraint is owned by the
actor and it should not be unreferenced directly
a #ClutterConstraint for the given
the name of the constraint to retrieve
Clears the list of constraints applied to @self
Animates the given list of properties of @actor between the current
value for each property and a new final value. The animation has a
definite duration and a speed given by the @mode.
For example, this:
|[
clutter_actor_animate (rectangle, CLUTTER_LINEAR, 250,
"width", 100.0,
"height", 100.0,
NULL);
]|
will make width and height properties of the #ClutterActor "rectangle"
grow linearly between the current value and 100 pixels, in 250 milliseconds.
The animation @mode is a logical id, either from the #ClutterAnimationMode
enumeration of from clutter_alpha_register_func().
All the properties specified will be animated between the current value
and the final value. If a property should be set at the beginning of
the animation but not updated during the animation, it should be prefixed
by the "fixed::" string, for instance:
|[
clutter_actor_animate (actor, CLUTTER_EASE_IN_SINE, 100,
"rotation-angle-z", 360.0,
"fixed::rotation-center-z", &center,
NULL);
]|
Will animate the "rotation-angle-z" property between the current value
and 360 degrees, and set the "rotation-center-z" property to the fixed
value of the #ClutterVertex "center".
This function will implicitly create a #ClutterAnimation object which
will be assigned to the @actor and will be returned to the developer
to control the animation or to know when the animation has been
completed.
If a name argument starts with "signal::", "signal-after::",
"signal-swapped::" or "signal-swapped-after::" the two following arguments
are used as callback function and data for a signal handler installed on
the #ClutterAnimation object for the specified signal name, for instance:
|[
static void
on_animation_completed (ClutterAnimation *animation,
ClutterActor *actor)
{
clutter_actor_hide (actor);
}
clutter_actor_animate (actor, CLUTTER_EASE_IN_CUBIC, 100,
"opacity", 0,
"signal::completed", on_animation_completed, actor,
NULL);
]|
or, to automatically destroy an actor at the end of the animation:
|[
clutter_actor_animate (actor, CLUTTER_EASE_IN_CUBIC, 100,
"opacity", 0,
"signal-swapped-after::completed",
clutter_actor_destroy,
actor,
NULL);
]|
The "signal::" modifier is the equivalent of using g_signal_connect();
the "signal-after::" modifier is the equivalent of using
g_signal_connect_after() or g_signal_connect_data() with the
%G_CONNECT_AFTER; the "signal-swapped::" modifier is the equivalent
of using g_signal_connect_swapped() or g_signal_connect_data() with the
%G_CONNECT_SWAPPED flah; finally, the "signal-swapped-after::" modifier
is the equivalent of using g_signal_connect_data() with both the
%G_CONNECT_AFTER and %G_CONNECT_SWAPPED flags. The clutter_actor_animate()
function will not keep track of multiple connections to the same signal,
so it is your responsability to avoid them when calling
clutter_actor_animate() multiple times on the same actor.
Calling this function on an actor that is already being animated
will cause the current animation to change with the new final values,
the new easing mode and the new duration - that is, this code:
|[
clutter_actor_animate (actor, CLUTTER_LINEAR, 250,
"width", 100.0,
"height", 100.0,
NULL);
clutter_actor_animate (actor, CLUTTER_EASE_IN_CUBIC, 500,
"x", 100.0,
"y", 100.0,
"width", 200.0,
NULL);
]|
is the equivalent of:
|[
clutter_actor_animate (actor, CLUTTER_EASE_IN_CUBIC, 500,
"x", 100.0,
"y", 100.0,
"width", 200.0,
"height", 100.0,
NULL);
]|
<note>Unless the animation is looping, the #ClutterAnimation created by
clutter_actor_animate() will become invalid as soon as it is
complete.</note>
Since the created #ClutterAnimation instance attached to @actor
is guaranteed to be valid throughout the #ClutterAnimation::completed
signal emission chain, you will not be able to create a new animation
using clutter_actor_animate() on the same @actor from within the
#ClutterAnimation::completed signal handler unless you use
g_signal_connect_after() to connect the callback function, for instance:
|[
static void
on_animation_completed (ClutterAnimation *animation,
ClutterActor *actor)
{
clutter_actor_animate (actor, CLUTTER_EASE_OUT_CUBIC, 250,
"x", 500.0,
"y", 500.0,
NULL);
}
...
animation = clutter_actor_animate (actor, CLUTTER_EASE_IN_CUBIC, 250,
"x", 100.0,
"y", 100.0,
NULL);
g_signal_connect (animation, "completed",
G_CALLBACK (on_animation_completed),
actor);
...
]|
owned by the #ClutterActor and should not be unreferenced with
g_object_unref()
a #ClutterAnimation object. The object is
an animation mode logical id
duration of the animation, in milliseconds
the name of a property
Animates the given list of properties of @actor between the current
value for each property and a new final value. The animation has a
definite duration given by @timeline and a speed given by the @mode.
See clutter_actor_animate() for further details.
This function is useful if you want to use an existing timeline
to animate @actor.
owned by the #ClutterActor and should not be unreferenced with
g_object_unref()
a #ClutterAnimation object. The object is
an animation mode logical id
a #ClutterTimeline
the name of a property
Animates the given list of properties of @actor between the current
value for each property and a new final value. The animation has a
definite behaviour given by the passed @alpha.
See clutter_actor_animate() for further details.
This function is useful if you want to use an existing #ClutterAlpha
to animate @actor.
#ClutterActor and should not be unreferenced with g_object_unref()
a #ClutterAnimation object. The object is owned by the
a #ClutterAlpha
the name of a property
Animates the given list of properties of @actor between the current
value for each property and a new final value. The animation has a
definite duration and a speed given by the @mode.
This is the vector-based variant of clutter_actor_animate(), useful
for language bindings.
<warning>Unlike clutter_actor_animate(), this function will not
allow you to specify "signal::" names and callbacks.</warning>
owned by the #ClutterActor and should not be unreferenced with
g_object_unref()
a #ClutterAnimation object. The object is
an animation mode logical id
duration of the animation, in milliseconds
number of property names and values
a vector containing the property names to set
a vector containing the property values to set
Animates the given list of properties of @actor between the current
value for each property and a new final value. The animation has a
definite duration given by @timeline and a speed given by the @mode.
See clutter_actor_animate() for further details.
This function is useful if you want to use an existing timeline
to animate @actor.
This is the vector-based variant of clutter_actor_animate_with_timeline(),
useful for language bindings.
<warning>Unlike clutter_actor_animate_with_timeline(), this function
will not allow you to specify "signal::" names and callbacks.</warning>
owned by the #ClutterActor and should not be unreferenced with
g_object_unref()
a #ClutterAnimation object. The object is
an animation mode logical id
a #ClutterTimeline
number of property names and values
a vector containing the property names to set
a vector containing the property values to set
Animates the given list of properties of @actor between the current
value for each property and a new final value. The animation has a
definite behaviour given by the passed @alpha.
See clutter_actor_animate() for further details.
This function is useful if you want to use an existing #ClutterAlpha
to animate @actor.
This is the vector-based variant of clutter_actor_animate_with_alpha(),
useful for language bindings.
<warning>Unlike clutter_actor_animate_with_alpha(), this function will
not allow you to specify "signal::" names and callbacks.</warning>
#ClutterActor and should not be unreferenced with g_object_unref()
a #ClutterAnimation object. The object is owned by the
a #ClutterAlpha
number of property names and values
a vector containing the property names to set
a vector containing the property values to set
Retrieves the #ClutterAnimation used by @actor, if clutter_actor_animate()
has been called on @actor.
a #ClutterAnimation, or %NULL
Adds a #ClutterAction to the actor
The allocation for the actor, in pixels
This is property is read-only, but you might monitor it to know when an
actor moves or resizes
The anchor point expressed as a #ClutterGravity
The X coordinate of an actor's anchor point, relative to
the actor coordinate space, in pixels
The Y coordinate of an actor's anchor point, relative to
the actor coordinate space, in pixels
The clip region for the actor, in actor-relative coordinates
Every part of the actor outside the clip region will not be
painted
Whether the clip region should track the allocated area
of the actor.
This property is ignored if a clip area has been explicitly
set using clutter_actor_set_clip().
Adds a #ClutterConstaint to the actor
The position of the actor on the Z axis
Adds #ClutterEffect to the list of effects be applied on a #ClutterActor
This flag controls whether the #ClutterActor:fixed-x and
#ClutterActor:fixed-y properties are used
The fixed X position of the actor in pixels.
Writing this property sets #ClutterActor:fixed-position-set
property as well, as a side effect
The fixed Y position of the actor in pixels.
Writing this property sets the #ClutterActor:fixed-position-set
property as well, as a side effect
Whether the actor has the #ClutterActor:clip property set or not
Whether the actor contains the pointer of a #ClutterInputDevice
or not.
Height of the actor (in pixels). If written, forces the minimum and
natural size request of the actor to the given height. If read, returns
the allocated height if available, otherwise the height request.
Whether the actor is mapped (will be painted when the stage
to which it belongs is mapped)
A forced minimum height request for the actor, in pixels
Writing this property sets the #ClutterActor:min-height-set property
as well, as a side effect. This property overrides the usual height
request of the actor.
This flag controls whether the #ClutterActor:min-height property
is used
A forced minimum width request for the actor, in pixels
Writing this property sets the #ClutterActor:min-width-set property
as well, as a side effect.
This property overrides the usual width request of the actor.
This flag controls whether the #ClutterActor:min-width property
is used
The name of the actor
A forced natural height request for the actor, in pixels
Writing this property sets the #ClutterActor:natural-height-set
property as well, as a side effect. This property overrides the
usual height request of the actor
This flag controls whether the #ClutterActor:natural-height property
is used
A forced natural width request for the actor, in pixels
Writing this property sets the #ClutterActor:natural-width-set
property as well, as a side effect. This property overrides the
usual width request of the actor
This flag controls whether the #ClutterActor:natural-width property
is used
Opacity of an actor, between 0 (fully transparent) and
255 (fully opaque)
Whether the actor is reactive to events or not
Only reactive actors will emit event-related signals
Whether the actor has been realized
Request mode for the #ClutterActor. The request mode determines the
type of geometry management used by the actor, either height for width
(the default) or width for height.
For actors implementing height for width, the parent container should get
the preferred width first, and then the preferred height for that width.
For actors implementing width for height, the parent container should get
the preferred height first, and then the preferred width for that height.
For instance:
|[
ClutterRequestMode mode;
gfloat natural_width, min_width;
gfloat natural_height, min_height;
mode = clutter_actor_get_request_mode (child);
if (mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
clutter_actor_get_preferred_width (child, -1,
&min_width,
&natural_width);
clutter_actor_get_preferred_height (child, natural_width,
&min_height,
&natural_height);
}
else
{
clutter_actor_get_preferred_height (child, -1,
&min_height,
&natural_height);
clutter_actor_get_preferred_width (child, natural_height,
&min_width,
&natural_width);
}
]|
will retrieve the minimum and natural width and height depending on the
preferred request mode of the #ClutterActor "child".
The clutter_actor_get_preferred_size() function will implement this
check for you.
The rotation angle on the X axis
The rotation angle on the Y axis
The rotation angle on the Z axis
The rotation center on the X axis.
The rotation center on the Y axis.
The rotation center on the Z axis.
The rotation center on the Z axis expressed as a #ClutterGravity.
The horizontal center point for scaling
The vertical center point for scaling
The center point for scaling expressed as a #ClutterGravity
The horizontal scale of the actor
The vertical scale of the actor
If %TRUE, the actor is automatically shown when parented.
Calling clutter_actor_hide() on an actor which has not been
parented will set this property to %FALSE as a side effect.
Whether the actor is set to be visible or not
See also #ClutterActor:mapped
Width of the actor (in pixels). If written, forces the minimum and
natural size request of the actor to the given width. If read, returns
the allocated width if available, otherwise the width request.
X coordinate of the actor in pixels. If written, forces a fixed
position for the actor. If read, returns the fixed position if any,
otherwise the allocation if available, otherwise 0.
Y coordinate of the actor in pixels. If written, forces a fixed
position for the actor. If read, returns the fixed position if
any, otherwise the allocation if available, otherwise 0.
The ::allocation-changed signal is emitted when the
#ClutterActor:allocation property changes. Usually, application
code should just use the notifications for the :allocation property
but if you want to track the allocation flags as well, for instance
to know whether the absolute origin of @actor changed, then you might
want use this signal instead.
a #ClutterActorBox with the new allocation
#ClutterAllocationFlags for the allocation
The ::button-press-event signal is emitted each time a mouse button
is pressed on @actor.
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterButtonEvent
The ::button-release-event signal is emitted each time a mouse button
is released on @actor.
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterButtonEvent
The ::captured-event signal is emitted when an event is captured
by Clutter. This signal will be emitted starting from the top-level
container (the #ClutterStage) to the actor which received the event
going down the hierarchy. This signal can be used to intercept every
event before the specialized events (like
ClutterActor::button-press-event or ::key-released-event) are
emitted.
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterEvent
The ::destroy signal is emitted when an actor is destroyed,
either by direct invocation of clutter_actor_destroy() or
when the #ClutterGroup that contains the actor is destroyed.
The ::enter-event signal is emitted when the pointer enters the @actor
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterCrossingEvent
The ::event signal is emitted each time an event is received
by the @actor. This signal will be emitted on every actor,
following the hierarchy chain, until it reaches the top-level
container (the #ClutterStage).
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterEvent
The ::hide signal is emitted when an actor is no longer rendered
on the stage.
The ::key-focus-in signal is emitted when @actor receives key focus.
The ::key-focus-out signal is emitted when @actor loses key focus.
The ::key-press-event signal is emitted each time a keyboard button
is pressed while @actor has key focus (see clutter_stage_set_key_focus()).
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterKeyEvent
The ::key-release-event signal is emitted each time a keyboard button
is released while @actor has key focus (see
clutter_stage_set_key_focus()).
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterKeyEvent
The ::leave-event signal is emitted when the pointer leaves the @actor.
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterCrossingEvent
The ::motion-event signal is emitted each time the mouse pointer is
moved over @actor.
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterMotionEvent
The ::paint signal is emitted each time an actor is being painted.
Subclasses of #ClutterActor should override the class signal handler
and paint themselves in that function.
It is possible to connect a handler to the ::paint signal in order
to set up some custom aspect of a paint.
This signal is emitted when the parent of the actor changes.
the previous parent of the actor, or %NULL
The ::pick signal is emitted each time an actor is being painted
in "pick mode". The pick mode is used to identify the actor during
the event handling phase, or by clutter_stage_get_actor_at_pos().
The actor should paint its shape using the passed @pick_color.
Subclasses of #ClutterActor should override the class signal handler
and paint themselves in that function.
It is possible to connect a handler to the ::pick signal in order
to set up some custom aspect of a paint in pick mode.
the #ClutterColor to be used when picking
The ::queue_redraw signal is emitted when clutter_actor_queue_redraw()
is called on @origin.
The default implementation for #ClutterActor chains up to the
parent actor and queues a redraw on the parent, thus "bubbling"
the redraw queue up through the actor graph. The default
implementation for #ClutterStage queues a clutter_redraw() in a
main loop idle handler.
Note that the @origin actor may be the stage, or a container; it
does not have to be a leaf node in the actor graph.
Toolkits embedding a #ClutterStage which require a redraw and
relayout cycle can stop the emission of this signal using the
GSignal API, redraw the UI and then call clutter_redraw()
themselves, like:
|[
static void
on_redraw_complete (void)
{
/* execute the Clutter drawing pipeline */
clutter_redraw ();
}
static void
on_stage_queue_redraw (ClutterStage *stage)
{
/* this prevents the default handler to run */
g_signal_stop_emission_by_name (stage, "queue-redraw");
/* queue a redraw with the host toolkit and call
* a function when the redraw has been completed
*/
queue_a_redraw (G_CALLBACK (on_redraw_complete));
}
]|
<note><para>This signal is emitted before the Clutter paint
pipeline is executed. If you want to know when the pipeline has
been completed you should connect to the ::paint signal on the
Stage with g_signal_connect_after().</para></note>
the actor which initiated the redraw request
The ::realize signal is emitted each time an actor is being
realized.
The ::scroll-event signal is emitted each time the mouse is
scrolled on @actor
or %FALSE to continue the emission.
%TRUE if the event has been handled by the actor,
a #ClutterScrollEvent
The ::show signal is emitted when an actor is visible and
rendered on the stage.
The ::unrealize signal is emitted each time an actor is being
unrealized.
Bounding box of an actor. The coordinates of the top left and right bottom
corners of an actor. The coordinates of the two points are expressed in
pixels with sub-pixel precision
Allocates a new #ClutterActorBox using the passed coordinates
for the top left and bottom right points
clutter_actor_box_free() to free the resources
the newly allocated #ClutterActorBox. Use
X coordinate of the top left point
Y coordinate of the top left point
X coordinate of the bottom right point
Y coordinate of the bottom right point
Copies @box
clutter_actor_box_free() to free the allocated resources
a newly allocated copy of #ClutterActorBox. Use
Frees a #ClutterActorBox allocated using clutter_actor_box_new()
or clutter_actor_box_copy()
Checks @box_a and @box_b for equality
%TRUE if the passed #ClutterActorBox are equal
a #ClutterActorBox
Retrieves the X coordinate of the origin of @box
the X coordinate of the origin
Retrieves the Y coordinate of the origin of @box
the Y coordinate of the origin
Retrieves the width of the @box
the width of the box
Retrieves the height of the @box
the height of the box
Retrieves the origin of @box
return location for the X coordinate, or %NULL
return location for the Y coordinate, or %NULL
Retrieves the size of @box
return location for the width, or %NULL
return location for the height, or %NULL
Retrieves the area of @box
the area of a #ClutterActorBox, in pixels
Checks whether a point with @x, @y coordinates is contained
withing @box
%TRUE if the point is contained by the #ClutterActorBox
X coordinate of the point
Y coordinate of the point
Calculates the bounding box represented by the four vertices; for details
of the vertex array see clutter_actor_get_abs_allocation_vertices().
array of four #ClutterVertex
Interpolates between @initial and @final #ClutterActorBox<!-- -->es
using @progress
the final #ClutterActorBox
the interpolation progress
return location for the interpolation
Clamps the components of @box to the nearest integer
Base class for actors.
available height when computing the preferred width, or a negative value to indicate that no height is defined
return location for minimum width, or %NULL
return location for the natural width, or %NULL
available width to assume in computing desired height, or a negative value to indicate that no width is defined
return location for minimum height, or %NULL
return location for natural height, or %NULL
new allocation of the actor, in parent-relative coordinates
flags that control the allocation
the #AtkObject associated with @actor
Flags used to signal the state of an actor.
The <structname>ClutterActorMeta</structname> structure contains only
private data and should be accessed using the provided API
Sets the name of @meta
The name can be used to identify the #ClutterActorMeta instance
the name of @meta
Retrieves the name set using clutter_actor_meta_set_name()
instance, or %NULL if none was set. The returned string is owned
by the #ClutterActorMeta instance and it should not be modified
or freed
the name of the #ClutterActorMeta
Sets whether @meta should be enabled or not
whether @meta is enabled
Retrieves whether @meta is enabled
%TRUE if the #ClutterActorMeta instance is enabled
Retrieves a pointer to the #ClutterActor that owns @meta
a pointer to a #ClutterActor or %NULL
The #ClutterActor attached to the #ClutterActorMeta instance
Whether or not the #ClutterActorMeta is enabled
The unique name to access the #ClutterActorMeta
The <structname>ClutterActorMetaClass</structname> structure contains
only private data
Specifies the axis on which #ClutterAlignConstraint should maintain
the alignment
<structname>ClutterAlignConstraint</structname> is an opaque structure
whose members cannot be directly accesses
Creates a new constraint, aligning a #ClutterActor's position with
regards of the size of the actor to @source, with the given
alignment @factor
the newly created #ClutterAlignConstraint
the #ClutterActor to use as the source of the alignment, or %NULL
the axis to be used to compute the alignment
the alignment factor, between 0.0 and 1.0
Sets the source of the alignment constraint
a #ClutterActor, or %NULL to unset the source
Retrieves the source of the alignment
of the alignment
the #ClutterActor used as the source
Sets the axis to which the alignment refers to
the axis to which the alignment refers to
Retrieves the value set using clutter_align_constraint_set_align_axis()
the alignment axis
Sets the alignment factor of the constraint
The factor depends on the #ClutterAlignConstraint:align-axis property
and it is a value between 0.0 (meaning left, when
#ClutterAlignConstraint:align-axis is set to %CLUTTER_ALIGN_X_AXIS; or
meaning top, when #ClutterAlignConstraint:align-axis is set to
%CLUTTER_ALIGN_Y_AXIS) and 1.0 (meaning right, when
#ClutterAlignConstraint:align-axis is set to %CLUTTER_ALIGN_X_AXIS; or
meaning bottom, when #ClutterAlignConstraint:align-axis is set to
%CLUTTER_ALIGN_Y_AXIS). A value of 0.5 aligns in the middle in either
cases
the alignment factor, between 0.0 and 1.0
Retrieves the factor set using clutter_align_constraint_set_factor()
the alignment factor
The axis to be used to compute the alignment
The alignment factor, as a normalized value between 0.0 and 1.0
The factor depends on the #ClutterAlignConstraint:align-axis property:
with an align-axis value of %CLUTTER_ALIGN_X_AXIS, 0.0 means left and
1.0 means right; with a value of %CLUTTER_ALIGN_Y_AXIS, 0.0 means top
and 1.0 means bottom.
The #ClutterActor used as the source for the alignment
Flags passed to the #ClutterActor::allocate() virtual function and
to the clutter_actor_allocate() function
#ClutterAlpha combines a #ClutterTimeline and a function.
The contents of the #ClutterAlpha structure are private and should
only be accessed using the provided API.
Creates a new #ClutterAlpha instance. You must set a function
to compute the alpha value using clutter_alpha_set_func() and
bind a #ClutterTimeline object to the #ClutterAlpha instance
using clutter_alpha_set_timeline().
You should use the newly created #ClutterAlpha instance inside
a #ClutterBehaviour object.
the newly created empty #ClutterAlpha instance.
Creates a new #ClutterAlpha instance and sets the timeline
and animation mode.
See also clutter_alpha_set_timeline() and clutter_alpha_set_mode().
the newly created #ClutterAlpha
#ClutterTimeline timeline
animation mode
Creates a new #ClutterAlpha instances and sets the timeline
and the alpha function.
This function will not register @func as a global alpha function.
See also clutter_alpha_set_timeline() and clutter_alpha_set_func().
the newly created #ClutterAlpha
a #ClutterTimeline
a #ClutterAlphaFunc
data to pass to the function, or %NULL
function to call when removing the alpha function, or %NULL
Registers a global alpha function and returns its logical id
to be used by clutter_alpha_set_mode() or by #ClutterAnimation.
The logical id is always greater than %CLUTTER_ANIMATION_LAST.
the logical id of the alpha function
a #ClutterAlphaFunc
user data to pass to @func, or %NULL
#GClosure variant of clutter_alpha_register_func().
Registers a global alpha function and returns its logical id
to be used by clutter_alpha_set_mode() or by #ClutterAnimation.
The logical id is always greater than %CLUTTER_ANIMATION_LAST.
the logical id of the alpha function
a #GClosure
Query the current alpha value.
The current alpha value for the alpha
Sets the #ClutterAlphaFunc function used to compute
the alpha value at each frame of the #ClutterTimeline
bound to @alpha.
This function will not register @func as a global alpha function.
A #ClutterAlphaFunc
user data to be passed to the alpha function, or %NULL
notify function used when disposing the alpha function
Sets the #GClosure used to compute the alpha value at each
frame of the #ClutterTimeline bound to @alpha.
A #GClosure
Binds @alpha to @timeline.
A #ClutterTimeline
Gets the #ClutterTimeline bound to @alpha.
a #ClutterTimeline instance
Sets the progress function of @alpha using the symbolic value
of @mode, as taken by the #ClutterAnimationMode enumeration or
using the value returned by clutter_alpha_register_func().
a #ClutterAnimationMode
Retrieves the #ClutterAnimationMode used by @alpha.
the animation mode
The alpha value as computed by the alpha function. The linear
interval is 0.0 to 1.0, but the Alpha allows overshooting by
one unit in each direction, so the valid interval is -1.0 to 2.0.
The progress function logical id - either a value from the
#ClutterAnimationMode enumeration or a value returned by
clutter_alpha_register_func().
If %CLUTTER_CUSTOM_MODE is used then the function set using
clutter_alpha_set_closure() or clutter_alpha_set_func()
will be used.
A #ClutterTimeline instance used to drive the alpha function.
Base class for #ClutterAlpha
A function returning a value depending on the position of
the #ClutterTimeline bound to @alpha.
a floating point value
a #ClutterAlpha
user data passed to the function
#ClutterAnimatable is an opaque structure whose members cannot be directly
accessed
Calls the animate_property() virtual function for @animatable.
The @initial_value and @final_value #GValue<!-- -->s must contain
the same type; @value must have been initialized to the same
type of @initial_value and @final_value.
All implementation of the #ClutterAnimatable interface must
implement this function.
be applied to the #ClutterAnimatable, and %FALSE otherwise
%TRUE if the value has been validated and can
a #ClutterAnimation
the name of the animated property
the initial value of the animation interval
the final value of the animation interval
the progress factor
return location for the animation value
Finds the #GParamSpec for @property_name
or %NULL
The #GParamSpec for the given property
the name of the animatable property to find
Retrieves the current state of @property_name and sets @value with it
the name of the animatable property to retrieve
a #GValue initialized to the type of the property to retrieve
Sets the current state of @property_name to @value
the name of the animatable property to set
the value of the animatable property to set
Calls the animate_property() virtual function for @animatable.
The @initial_value and @final_value #GValue<!-- -->s must contain
the same type; @value must have been initialized to the same
type of @initial_value and @final_value.
All implementation of the #ClutterAnimatable interface must
implement this function.
be applied to the #ClutterAnimatable, and %FALSE otherwise
%TRUE if the value has been validated and can
a #ClutterAnimation
the name of the animated property
the initial value of the animation interval
the final value of the animation interval
the progress factor
return location for the animation value
Finds the #GParamSpec for @property_name
or %NULL
The #GParamSpec for the given property
the name of the animatable property to find
Retrieves the current state of @property_name and sets @value with it
the name of the animatable property to retrieve
a #GValue initialized to the type of the property to retrieve
Sets the current state of @property_name to @value
the name of the animatable property to set
the value of the animatable property to set
Base interface for #GObject<!-- -->s that can be animated by a
a #ClutterAnimation.
%TRUE if the value has been validated and can
a #ClutterAnimation
the name of the animated property
the initial value of the animation interval
the final value of the animation interval
the progress factor
return location for the animation value
The #GParamSpec for the given property
the name of the animatable property to find
the name of the animatable property to retrieve
a #GValue initialized to the type of the property to retrieve
the name of the animatable property to set
the value of the animatable property to set
The #ClutterAnimation structure contains only private data and should
be accessed using the provided functions.
Creates a new #ClutterAnimation instance. You should set the
#GObject to be animated using clutter_animation_set_object(),
set the duration with clutter_animation_set_duration() and the
easing mode using clutter_animation_set_mode().
Use clutter_animation_bind() or clutter_animation_bind_interval()
to define the properties to be animated. The interval and the
animated properties can be updated at runtime.
The clutter_actor_animate() and relative family of functions provide
an easy way to animate a #ClutterActor and automatically manage the
lifetime of a #ClutterAnimation instance, so you should consider using
those functions instead of manually creating an animation.
to release the associated resources
the newly created #ClutterAnimation. Use g_object_unref()
Attaches @animation to @object. The #ClutterAnimation will take a
reference on @object.
a #GObject
Retrieves the #GObject attached to @animation.
a #GObject
Sets the animation @mode of @animation. The animation @mode is
a logical id, either coming from the #ClutterAnimationMode enumeration
or the return value of clutter_alpha_register_func().
This function will also set #ClutterAnimation:alpha if needed.
an animation mode logical id
Retrieves the animation mode of @animation, as set by
clutter_animation_set_mode().
the mode for the animation
Sets the duration of @animation in milliseconds.
This function will set #ClutterAnimation:alpha and
#ClutterAnimation:timeline if needed.
the duration in milliseconds
Retrieves the duration of @animation, in milliseconds.
the duration of the animation
Sets whether @animation should loop over itself once finished.
A looping #ClutterAnimation will not emit the #ClutterAnimation::completed
signal when finished.
This function will set #ClutterAnimation:alpha and
#ClutterAnimation:timeline if needed.
%TRUE if the animation should loop
Retrieves whether @animation is looping.
%TRUE if the animation is looping
Sets the #ClutterTimeline used by @animation.
a #ClutterTimeline, or %NULL to unset the current #ClutterTimeline
Retrieves the #ClutterTimeline used by @animation
the timeline used by the animation
Sets @alpha as the #ClutterAlpha used by @animation.
If @alpha is not %NULL, the #ClutterAnimation will take ownership
of the #ClutterAlpha instance.
a #ClutterAlpha, or %NULL to unset the current #ClutterAlpha
Retrieves the #ClutterAlpha used by @animation.
the alpha object used by the animation
Adds a single property with name @property_name to the
animation @animation. For more information about animations,
see clutter_actor_animate().
This method returns the animation primarily to make chained
calls convenient in language bindings.
The animation itself.
the property to control
The final value of the property
Binds @interval to the @property_name of the #GObject
attached to @animation. The #ClutterAnimation will take
ownership of the passed #ClutterInterval. For more information
about animations, see clutter_actor_animate().
If you need to update the interval instance use
clutter_animation_update_property() instead.
The animation itself.
the property to control
a #ClutterInterval
Checks whether @animation is controlling @property_name.
#ClutterAnimation, %FALSE otherwise
%TRUE if the property is animated by the
name of the property
Updates the @final value of the interval for @property_name
The animation itself.
name of the property
The final value of the property
Changes the @interval for @property_name. The #ClutterAnimation
will take ownership of the passed #ClutterInterval.
name of the property
a #ClutterInterval
Removes @property_name from the list of animated properties.
name of the property
Retrieves the #ClutterInterval associated to @property_name
inside @animation.
property with the same name was found. The returned interval is
owned by the #ClutterAnimation and should not be unreferenced
a #ClutterInterval or %NULL if no
name of the property
Emits the ::completed signal on @animation
When using this function with a #ClutterAnimation created
by the clutter_actor_animate() family of functions, @animation
will be unreferenced and it will not be valid anymore,
unless g_object_ref() was called before calling this function
or unless a reference was taken inside a handler for the
#ClutterAnimation::completed signal
The #ClutterAlpha used by the animation.
The duration of the animation, expressed in milliseconds.
Whether the animation should loop.
The animation mode, either a value from #ClutterAnimationMode
or a value returned by clutter_alpha_register_func(). The
default value is %CLUTTER_LINEAR.
The #GObject to which the animation applies.
The #ClutterTimeline used by the animation.
The ::completed signal is emitted once the animation has
been completed.
The @animation instance is guaranteed to be valid for the entire
duration of the signal emission chain.
The ::started signal is emitted once the animation has been
started
The #ClutterAnimationClass structure contains only private data and
should be accessed using the provided functions.
The animation modes used by #ClutterAlpha and #ClutterAnimation. This
enumeration can be expanded in later versions of Clutter. See the
#ClutterAlpha documentation for a graph of all the animation modes.
Every global alpha function registered using clutter_alpha_register_func()
or clutter_alpha_register_closure() will have a logical id greater than
%CLUTTER_ANIMATION_LAST.
The #ClutterAnimator structure contains only private data and
should be accessed using the provided API
Creates a new #ClutterAnimator instance
a new #ClutterAnimator.
Sets a single key in the #ClutterAnimator for the @property_name of
The animator instance
a #GObject
the property to specify a key for
the id of the alpha function to use
the normalized range at which stage of the animation this value applies
the value property_name should have at progress.
Adds multiple keys to a #ClutterAnimator, specifying the value a given
property should have at a given progress of the animation. The mode
specified is the mode used when going to this key from the previous key of
the @property_name
If a given (object, property, progress) tuple already exist the mode and
value will be replaced with the new values.
a #GObject
the property to specify a key for
the id of the alpha function to use
at which stage of the animation this value applies; the range is a normalized floating point value between 0 and 1
Returns a list of pointers to opaque structures with accessor functions
that describe the keys added to an animator.
list of #ClutterAnimatorKey<!-- -->s; the contents of the list are owned
by the #ClutterAnimator, but you should free the returned list when done,
using g_list_free()
a
a #GObject to search for, or %NULL for all objects
a specific property name to query for, or %NULL for all properties
a specific progress to search for, or a negative value for all progresses
Removes all keys matching the conditions specificed in the arguments.
a #GObject to search for, or %NULL for all
a specific property name to query for, or %NULL for all
a specific progress to search for or a negative value for all
Start the ClutterAnimator, this is a thin wrapper that rewinds
and starts the animators current timeline.
the #ClutterTimeline that drives the animator.
Compute the value for a managed property at a given progress.
If the property is an ease-in property, the current value of the property
on the object will be used as the starting point for computation.
an error occurs or the progress is before any of the keys) %FALSE is
returned and the #GValue is left untouched
%TRUE if the computation yields has a value, otherwise (when
a #GObject
the name of the property on object to check
a value between 0.0 and 1.0
an initialized value to store the computed result
Get the timeline hooked up for driving the #ClutterAnimator
the #ClutterTimeline that drives the animator
Sets an external timeline that will be used for driving the animation
a #ClutterTimeline
Retrieves the current duration of an animator
the duration of the animation, in milliseconds
Runs the timeline of the #ClutterAnimator with a duration in msecs
as specified.
milliseconds a run of the animator should last.
Checks if a property value is to be eased into the animation.
%TRUE if the property is eased in
a #GObject
the name of a property on object
Sets whether a property value is to be eased into the animation.
a #GObject
the name of a property on object
we are going to be easing in this property
Get the interpolation used by animator for a property on a particular
object.
a ClutterInterpolation value.
a #GObject
the name of a property on object
Set the interpolation method to use, %CLUTTER_INTERPOLATION_LINEAR causes
the values to linearly change between the values, and
%CLUTTER_INTERPOLATION_CUBIC causes the values to smoothly change between
the values.
a #GObject
the name of a property on object
the #ClutterInterpolation to use
The duration of the #ClutterTimeline used by the #ClutterAnimator
to drive the animation
The #ClutterTimeline used by the #ClutterAnimator to drive the
animation
The #ClutterAnimatorClass structure contains only private data
A key frame inside a #ClutterAnimator
Retrieves the object a key applies to.
the object an animator_key exist for.
Retrieves the name of the property a key applies to.
the name of the property an animator_key exist for.
Retrieves the #GType of the property a key applies to
You can use this type to initialize the #GValue to pass to
clutter_animator_key_get_value()
the #GType of the property
Retrieves the mode of a #ClutterAnimator key, for the first key of a
property for an object this represents the whether the animation is
open ended and or curved for the remainding keys for the property it
represents the easing mode.
the mode of a #ClutterAnimatorKey
Retrieves the progress of an clutter_animator_key
the progress defined for a #ClutterAnimator key.
Retrieves a copy of the value for a #ClutterAnimatorKey.
The passed in #GValue needs to be already initialized for the value
type of the key or to a type that allow transformation from the value
type of the key.
Use g_value_unset() when done.
%FALSE otherwise
%TRUE if the passed #GValue was successfully set, and
a #GValue initialized with the correct type for the animator key
Common members for a #ClutterEvent
Sets the resolution for font handling on the screen. This is a
scale factor between points specified in a #PangoFontDescription
and cairo units. The default value is 96, meaning that a 10 point
font will be 13 units high. (10 * 96. / 72. = 13.3).
Applications should never need to call this function.
the resolution in "dots per inch" (Physical inches aren't actually involved; the terminology is conventional).
Sets the maximum time between two button press events, used to
verify whether it's a double click event or not.
milliseconds between two button press events
Gets the maximum time between two button press events, as set
by clutter_backend_set_double_click_time().
a time in milliseconds
Sets the maximum distance used to verify a double click event.
a distance, in pixels
Retrieves the distance used to verify a double click event
a distance, in pixels.
Sets the default font to be used by Clutter. The @font_name string
must either be %NULL, which means that the font name from the
default #ClutterBackend will be used; or be something that can
be parsed by the pango_font_description_from_string() function.
the name of the font
Retrieves the default font name as set by
clutter_backend_set_font_name().
owned by the #ClutterBackend and should never be modified or freed
the font name for the backend. The returned string is
Gets the resolution for font handling on the screen.
The resolution is a scale factor between points specified in a
#PangoFontDescription and cairo units. The default value is 96.0,
meaning that a 10 point font will be 13 units
high (10 * 96. / 72. = 13.3).
Clutter will set the resolution using the current backend when
initializing; the resolution is also stored in the
#ClutterSettings:font-dpi property.
has been set.
the current resolution, or -1 if no resolution
Sets the new font options for @backend. The #ClutterBackend will
copy the #cairo_font_options_t.
If @options is %NULL, the first following call to
clutter_backend_get_font_options() will return the default font
options for @backend.
This function is intended for actors creating a Pango layout
using the PangoCairo API.
Cairo font options for the backend, or %NULL
Retrieves the font options for @backend.
The returned #cairo_font_options_t is owned by the backend and should
not be modified or freed
the font options of the #ClutterBackend.
#ClutterBehaviour-struct contains only private data and should
be accessed with the functions below.
Applies @behave to @actor. This function adds a reference on
the actor.
a #ClutterActor
Removes @actor from the list of #ClutterActor<!-- -->s to which
a #ClutterActor
Removes every actor from the list that @behave holds.
Calls @func for every actor driven by @behave.
a function called for each actor
optional data to be passed to the function, or %NULL
Gets the number of actors this behaviour is applied too.
The number of applied actors
Gets an actor the behaviour was applied to referenced by index num.
A Clutter actor or NULL if @index_ is invalid.
the index of an actor this behaviour is applied too.
Retrieves all the actors to which @behave applies. It is not recommended
for derived classes to use this in there alpha notify method but use
#clutter_behaviour_actors_foreach as it avoids alot of needless allocations.
actors. You should free the returned list with g_slist_free() when
finished using it.
a list of
Retrieves the #ClutterAlpha object bound to @behave.
object has been bound to this behaviour.
a #ClutterAlpha object, or %NULL if no alpha
Binds @alpha to a #ClutterBehaviour. The #ClutterAlpha object
used by #ClutterAlpha a new value of the alpha parameter is
computed by the alpha function; the value should be used by
the #ClutterBehaviour to update one or more properties of the
actors to which the behaviour applies.
If @alpha is not %NULL, the #ClutterBehaviour will take ownership
of the #ClutterAlpha instance.
a #ClutterAlpha or %NULL to unset a previously set alpha
Check if @behave applied to @actor.
TRUE if actor has behaviour. FALSE otherwise.
a #ClutterActor
The #ClutterAlpha object used to drive this behaviour. A #ClutterAlpha
object binds a #ClutterTimeline and a function which computes a value
(the "alpha") depending on the time. Each time the alpha value changes
the alpha-notify virtual function is called.
The ::apply signal is emitted each time the behaviour is applied
to an actor.
the actor the behaviour was applied to.
The ::removed signal is emitted each time a behaviour is not applied
to an actor anymore.
the removed actor
The #ClutterBehaviourDepth structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterBehaviourDepth which can be used to control
the ClutterActor:depth property of a set of #ClutterActor<!-- -->s.
the newly created behaviour
a #ClutterAlpha or %NULL
initial value of the depth
final value of the depth
Sets the boundaries of the @behaviour.
initial value of the depth
final value of the depth
Gets the boundaries of the @behaviour
return location for the initial depth value, or %NULL
return location for the final depth value, or %NULL
End depth level to apply to the actors.
Start depth level to apply to the actors.
The #ClutterBehaviourDepthClass structure contains only private data
The #ClutterBehaviourEllipse struct contains only private data
and should be accessed using the provided API
Creates a behaviour that drives actors along an elliptical path with
given center, width and height; the movement starts at @start
degrees (with 0 corresponding to 12 o'clock) and ends at @end
degrees. Angles greated than 360 degrees get clamped to the canonical
interval <0, 360); if @start is equal to @end, the behaviour will
rotate by exacly 360 degrees.
the newly created #ClutterBehaviourEllipse
a #ClutterAlpha, or %NULL
x coordinace of the center
y coordiance of the center
width of the ellipse
height of the ellipse
#ClutterRotateDirection of rotation
angle in degrees at which movement starts, between 0 and 360
angle in degrees at which movement ends, between 0 and 360
Sets the center of the elliptical path to the point represented by knot.
x coordinace of centre
y coordinace of centre
Gets the center of the elliptical path path.
return location for the X coordinate of the center, or %NULL
return location for the Y coordinate of the center, or %NULL
Sets the width of the elliptical path.
width of the ellipse
Gets the width of the elliptical path.
the width of the path
Sets the height of the elliptical path.
height of the ellipse
Gets the height of the elliptical path.
the height of the path
Sets the angle at which movement starts; angles >= 360 degress get clamped
to the canonical interval <0, 360).
angle at which movement starts in degrees, between 0 and 360.
Gets the angle at which movements starts.
angle in degrees
Sets the angle at which movement ends; angles >= 360 degress get clamped
to the canonical interval <0, 360).
angle at which movement ends in degrees, between 0 and 360.
Gets the at which movements ends.
angle in degrees
Sets the angle at which the ellipse should be tilted around it's center.
a #ClutterRotateAxis
tilt of the elipse around the center in the given axis in degrees.
Gets the tilt of the ellipse around the center in the given axis.
angle in degrees.
a #ClutterRotateAxis
Sets the angles at which the ellipse should be tilted around it's center.
tilt of the elipse around the center in X axis in degrees.
tilt of the elipse around the center in Y axis in degrees.
tilt of the elipse around the center in Z axis in degrees.
Gets the tilt of the ellipse around the center in Y axis.
return location for tilt angle on the X axis, or %NULL.
return location for tilt angle on the Y axis, or %NULL.
return location for tilt angle on the Z axis, or %NULL.
Retrieves the #ClutterRotateDirection used by the ellipse behaviour.
the rotation direction
Sets the rotation direction used by the ellipse behaviour.
the rotation direction
The final angle to where the rotation should end.
The initial angle from where the rotation should start.
The tilt angle for the rotation around center in X axis
The tilt angle for the rotation around center in Y axis
The tilt angle for the rotation on the Z axis
The center of the ellipse.
The direction of the rotation.
Height of the ellipse, in pixels
Width of the ellipse, in pixels
The #ClutterBehaviourEllipseClass struct contains only private data
This function is passed to clutter_behaviour_foreach_actor() and
will be called for each actor driven by @behaviour.
the #ClutterBehaviour
an actor driven by @behaviour
optional data passed to the function
The #ClutterBehaviourOpacity structure contains only private data and
should be accessed using the provided API
Creates a new #ClutterBehaviourOpacity object, driven by @alpha
which controls the opacity property of every actor, making it
change in the interval between @opacity_start and @opacity_end.
the newly created #ClutterBehaviourOpacity
a #ClutterAlpha instance, or %NULL
minimum level of opacity
maximum level of opacity
Sets the initial and final levels of the opacity applied by @behaviour
on each actor it controls.
minimum level of opacity
maximum level of opacity
Gets the initial and final levels of the opacity applied by @behaviour
on each actor it controls.
return location for the minimum level of opacity, or %NULL
return location for the maximum level of opacity, or %NULL
Final opacity level of the behaviour.
Initial opacity level of the behaviour.
The #ClutterBehaviourOpacityClass structure contains only private data
The #ClutterBehaviourPath structure contains only private data
and should be accessed using the provided API
Creates a new path behaviour. You can use this behaviour to drive
actors along the nodes of a path, described by @path.
This will claim the floating reference on the #ClutterPath so you
do not need to unref if it.
a #ClutterBehaviour
a #ClutterAlpha, or %NULL
a #ClutterPath or %NULL for an empty path
Creates a new path behaviour using the path described by @desc. See
clutter_path_add_string() for a description of the format.
a #ClutterBehaviour
a #ClutterAlpha
a string description of the path
Creates a new path behaviour that will make the actors visit all of
the given knots in order with straight lines in between.
A path will be created where the first knot is used in a
%CLUTTER_PATH_MOVE_TO and the subsequent knots are used in
%CLUTTER_PATH_LINE_TO<!-- -->s.
a #ClutterBehaviour
a #ClutterAlpha
an array of #ClutterKnot<!-- -->s
number of entries in @knots
Change the path that the actors will follow. This will take the
floating reference on the #ClutterPath so you do not need to unref
it.
the new path to follow
Get the current path of the behaviour
the path
This signal is emitted each time a node defined inside the path
is reached.
the index of the #ClutterKnot reached
The #ClutterBehaviourRotate struct contains only private data and
should be accessed using the provided API
Creates a new #ClutterBehaviourRotate. This behaviour will rotate actors
bound to it on @axis, following @direction, between @angle_start and
<0, 360), if angle_start == angle_end, the behaviour will carry out a
single rotation of 360 degrees.
the newly created #ClutterBehaviourRotate.
a #ClutterAlpha, or %NULL
the rotation axis
the rotation direction
the starting angle in degrees, between 0 and 360.
the final angle in degrees, between 0 and 360.
Retrieves the center of rotation set using
clutter_behaviour_rotate_set_center().
return location for the X center of rotation
return location for the Y center of rotation
return location for the Z center of rotation
Sets the center of rotation. The coordinates are relative to the plane
normal to the rotation axis set with clutter_behaviour_rotate_set_axis().
X axis center of rotation
Y axis center of rotation
Z axis center of rotation
Retrieves the #ClutterRotateAxis used by the rotate behaviour.
the rotation axis
Sets the axis used by the rotate behaviour.
a #ClutterRotateAxis
Retrieves the #ClutterRotateDirection used by the rotate behaviour.
the rotation direction
Sets the rotation direction used by the rotate behaviour.
the rotation direction
Retrieves the rotation boundaries of the rotate behaviour.
return value for the initial angle
return value for the final angle
Sets the initial and final angles of a rotation behaviour; angles >= 360
degrees get clamped to the canonical interval <0, 360).
initial angle in degrees, between 0 and 360.
final angle in degrees, between 0 and 360.
The final angle to where the rotation should end.
The initial angle from whence the rotation should start.
The axis of rotation.
The x center of rotation.
The y center of rotation.
The z center of rotation.
The direction of the rotation.
The #ClutterBehaviourRotateClass struct contains only private data
The #ClutterBehaviourScale struct contains only private data and
should be accessed using the provided API
Creates a new #ClutterBehaviourScale instance.
the newly created #ClutterBehaviourScale
a #ClutterAlpha
initial scale factor on the X axis
initial scale factor on the Y axis
final scale factor on the X axis
final scale factor on the Y axis
Sets the bounds used by scale behaviour.
initial scale factor on the X axis
initial scale factor on the Y axis
final scale factor on the X axis
final scale factor on the Y axis
Retrieves the bounds used by scale behaviour.
return location for the initial scale factor on the X axis, or %NULL
return location for the initial scale factor on the Y axis, or %NULL
return location for the final scale factor on the X axis, or %NULL
return location for the final scale factor on the Y axis, or %NULL
The final scaling factor on the X axis for the actors.
The initial scaling factor on the X axis for the actors.
The final scaling factor on the Y axis for the actors.
The initial scaling factor on the Y axis for the actors.
The #ClutterBehaviourScaleClass struct contains only private data
The alignment policies available on each axis for #ClutterBinLayout
The #ClutterBinLayout structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterBinLayout layout manager
the newly created layout manager
the default alignment policy to be used on the horizontal axis
the default alignment policy to be used on the vertical axis
Sets the horizontal and vertical alignment policies to be applied
to a @child of @self
If @child is %NULL then the @x_align and @y_align values will
be set as the default alignment policies
a child of @container
the horizontal alignment policy to be used for the @child inside @container
the vertical aligment policy to be used on the @child inside @container
Retrieves the horizontal and vertical alignment policies for
a child of @self
If @child is %NULL the default alignment policies will be returned
instead
a child of @container
return location for the horizontal alignment policy
return location for the vertical alignment policy
Adds a #ClutterActor to the container using @self and
sets the alignment policies for it
This function is equivalent to clutter_container_add_actor()
and clutter_layout_manager_child_set_property() but it does not
require a pointer to the #ClutterContainer associated to the
#ClutterBinLayout
a #ClutterActor
horizontal alignment policy for @child
vertical alignment policy for @child
The default horizontal alignment policy for actors managed
by the #ClutterBinLayout
The default vertical alignment policy for actors managed
by the #ClutterBinLayout
The #ClutterBinLayoutClass structure contains only private
data and should be accessed using the provided API
<structname>ClutterBindConstraint</structname> is an opaque structure
whose members cannot be directly accessed
Creates a new constraint, binding a #ClutterActor's position to
the given @coordinate of the position of @source
the newly created #ClutterBindConstraint
the #ClutterActor to use as the source of the binding, or %NULL
the coordinate to bind
the offset to apply to the binding, in pixels
Sets the source #ClutterActor for the constraint
a #ClutterActor, or %NULL to unset the source
Retrieves the #ClutterActor set using clutter_bind_constraint_set_source()
a pointer to the source actor
Sets the coordinate to bind in the constraint
the coordinate to bind
Retrieves the bound coordinate of the constraint
the bound coordinate
Sets the offset to be applied to the constraint
the offset to apply, in pixels
Retrieves the offset set using clutter_bind_constraint_set_offset()
the offset, in pixels
The coordinate to be bound
The offset, in pixels, to be applied to the binding
The #ClutterActor used as the source for the binding
Specifies which property should be used in a binding
The prototype for the callback function registered with
clutter_binding_pool_install_action() and invoked by
clutter_binding_pool_activate().
binding has been handled, and return %FALSE otherwise
the function should return %TRUE if the key
a #GObject
the name of the action
the key symbol
bitmask of the modifier flags
Container of key bindings. The #ClutterBindingPool struct is
private.
Creates a new #ClutterBindingPool that can be used to store
key bindings for an actor. The @name must be a unique identifier
for the binding pool, so that clutter_binding_pool_find() will
be able to return the correct binding pool.
name. Use g_object_unref() when done.
the newly created binding pool with the given
the name of the binding pool
Retrieves the #ClutterBindingPool for the given #GObject class
and, eventually, creates it. This function is a wrapper around
clutter_binding_pool_new() and uses the class type name as the
unique name for the binding pool.
Calling this function multiple times will return the same
#ClutterBindingPool.
A binding pool for a class can also be retrieved using
clutter_binding_pool_find() with the class type name:
|[
pool = clutter_binding_pool_find (G_OBJECT_TYPE_NAME (instance));
]|
The returned #ClutterBindingPool is owned by Clutter and should not
be freed directly
the binding pool for the given class.
a #GObjectClass pointer
Finds the #ClutterBindingPool with @name.
a pointer to the #ClutterBindingPool, or %NULL
the name of the binding pool to find
Installs a new action inside a #ClutterBindingPool. The action
is bound to @key_val and @modifiers.
The same action name can be used for multiple @key_val, @modifiers
pairs.
When an action has been activated using clutter_binding_pool_activate()
the passed @callback will be invoked (with @data).
Actions can be blocked with clutter_binding_pool_block_action()
and then unblocked using clutter_binding_pool_unblock_action().
the name of the action
key symbol
bitmask of modifiers
function to be called when the action is activated
data to be passed to @callback
function to be called when the action is removed from the pool
A #GClosure variant of clutter_binding_pool_install_action().
Installs a new action inside a #ClutterBindingPool. The action
is bound to @key_val and @modifiers.
The same action name can be used for multiple @key_val, @modifiers
pairs.
When an action has been activated using clutter_binding_pool_activate()
the passed @closure will be invoked.
Actions can be blocked with clutter_binding_pool_block_action()
and then unblocked using clutter_binding_pool_unblock_action().
the name of the action
key symbol
bitmask of modifiers
a #GClosure
Allows overriding the action for @key_val and @modifiers inside a
#ClutterBindingPool. See clutter_binding_pool_install_action().
When an action has been activated using clutter_binding_pool_activate()
the passed @callback will be invoked (with @data).
Actions can be blocked with clutter_binding_pool_block_action()
and then unblocked using clutter_binding_pool_unblock_action().
key symbol
bitmask of modifiers
function to be called when the action is activated
data to be passed to @callback
function to be called when the action is removed from the pool
A #GClosure variant of clutter_binding_pool_override_action().
Allows overriding the action for @key_val and @modifiers inside a
#ClutterBindingPool. See clutter_binding_pool_install_closure().
When an action has been activated using clutter_binding_pool_activate()
the passed @callback will be invoked (with @data).
Actions can be blocked with clutter_binding_pool_block_action()
and then unblocked using clutter_binding_pool_unblock_action().
key symbol
bitmask of modifiers
a #GClosure
Retrieves the name of the action matching the given key symbol
and modifiers bitmask.
returned string is owned by the binding pool and should never
be modified or freed
the name of the action, if found, or %NULL. The
a key symbol
a bitmask for the modifiers
Removes the action matching the given @key_val, @modifiers pair,
if any exists.
a key symbol
a bitmask for the modifiers
Activates the callback associated to the action that is
bound to the @key_val and @modifiers pair.
The callback has the following signature:
|[
void (* callback) (GObject *gobject,
const gchar *action_name,
guint key_val,
ClutterModifierType modifiers,
gpointer user_data);
]|
Where the #GObject instance is @gobject and the user data
is the one passed when installing the action with
clutter_binding_pool_install_action().
If the action bound to the @key_val, @modifiers pair has been
blocked using clutter_binding_pool_block_action(), the callback
will not be invoked, and this function will return %FALSE.
%TRUE if an action was found and was activated
the key symbol
bitmask for the modifiers
a #GObject
Blocks all the actions with name @action_name inside @pool.
an action name
Unblockes all the actions with name @action_name inside @pool.
Unblocking an action does not cause the callback bound to it to
be invoked in case clutter_binding_pool_activate() was called on
an action previously blocked with clutter_binding_pool_block_action().
an action name
The unique name of the #ClutterBindingPool.
<structname>ClutterBlurEffect</structname> is an opaque structure
whose members cannot be accessed directly
Creates a new #ClutterBlurEffect to be used with
clutter_actor_add_effect()
the newly created #ClutterBlurEffect or %NULL
The #ClutterBox structure contains only private data and should
be accessed using the provided API
Creates a new #ClutterBox. The children of the box will be layed
out by the passed @manager
the newly created #ClutterBox actor
a #ClutterLayoutManager
Sets the #ClutterLayoutManager for @box
A #ClutterLayoutManager is a delegate object that controls the
layout of the children of @box
a #ClutterLayoutManager
Retrieves the #ClutterLayoutManager instance used by @box
a #ClutterLayoutManager
Sets (or unsets) the background color for @box
the background color, or %NULL to unset
Retrieves the background color of @box
If the #ClutterBox:color-set property is set to %FALSE the
returned #ClutterColor is undefined
return location for a #ClutterColor
Adds @actor to @box and sets layout properties at the same time,
if the #ClutterLayoutManager used by @box has them
This function is a wrapper around clutter_container_add_actor()
and clutter_layout_manager_child_set()
Language bindings should use the vector-based clutter_box_addv()
variant instead
a #ClutterActor
the name of the first property to set, or %NULL
Vector-based variant of clutter_box_pack(), intended for language
bindings to use
a #ClutterActor
the number of properties to set
a vector containing the property names to set
a vector containing the property values to set
Adds @actor to @box, placing it after @sibling, and sets layout
properties at the same time, if the #ClutterLayoutManager used by
If @sibling is %NULL then @actor is placed at the end of the
list of children, to be allocated and painted after every other child
This function is a wrapper around clutter_container_add_actor(),
clutter_container_raise_child() and clutter_layout_manager_child_set()
a #ClutterActor
a #ClutterActor or %NULL
the name of the first property to set, or %NULL
Adds @actor to @box, placing it before @sibling, and sets layout
properties at the same time, if the #ClutterLayoutManager used by
If @sibling is %NULL then @actor is placed at the beginning of the
list of children, to be allocated and painted below every other child
This function is a wrapper around clutter_container_add_actor(),
clutter_container_lower_child() and clutter_layout_manager_child_set()
a #ClutterActor
a #ClutterActor or %NULL
the name of the first property to set, or %NULL
Adds @actor to @box, placing it at @position, and sets layout
properties at the same time, if the #ClutterLayoutManager used by
If @position is a negative number, or is larger than the number of
children of @box, the new child is added at the end of the list of
children
a #ClutterActor
the position to insert the @actor at
the name of the first property to set, or %NULL
The color to be used to paint the background of the
#ClutterBox. Setting this property will set the
#ClutterBox:color-set property as a side effect
Whether the #ClutterBox:color property has been set
The #ClutterLayoutManager used by the #ClutterBox
The alignment policies available on each axis of the #ClutterBoxLayout
The #ClutterBoxClass structure contains only private data
The #ClutterBoxLayout structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterBoxLayout layout manager
the newly created #ClutterBoxLayout
Sets the spacing between children of @layout
the spacing between children of the layout, in pixels
Retrieves the spacing set using clutter_box_layout_set_spacing()
the spacing between children of the #ClutterBoxLayout
Sets whether @layout should arrange its children vertically alongside
the Y axis, instead of horizontally alongside the X axis
%TRUE if the layout should be vertical
Retrieves the orientation of the @layout as set using the
clutter_box_layout_set_vertical() function
vertically, and %FALSE otherwise
%TRUE if the #ClutterBoxLayout is arranging its children
Sets whether the size of @layout children should be
homogeneous
%TRUE if the layout should be homogeneous
Retrieves if the children sizes are allocated homogeneously.
homogeneously, and %FALSE otherwise
%TRUE if the #ClutterBoxLayout is arranging its children
Sets whether children of @layout should be layed out by appending
them or by prepending them
%TRUE if the @layout should pack children at the beginning of the layout
Retrieves the value set using clutter_box_layout_set_pack_start()
at the beginning of the layout, and %FALSE otherwise
%TRUE if the #ClutterBoxLayout should pack children
Packs @actor inside the #ClutterContainer associated to @layout
and sets the layout properties
a #ClutterActor
whether the @actor should expand
whether the @actor should fill horizontally
whether the @actor should fill vertically
the horizontal alignment policy for @actor
the vertical alignment policy for @actor
Sets the horizontal and vertical alignment policies for @actor
inside @layout
a #ClutterActor child of @layout
Horizontal alignment policy for @actor
Vertical alignment policy for @actor
Retrieves the horizontal and vertical alignment policies for @actor
as set using clutter_box_layout_pack() or clutter_box_layout_set_alignment()
a #ClutterActor child of @layout
return location for the horizontal alignment policy
return location for the vertical alignment policy
Sets the horizontal and vertical fill policies for @actor
inside @layout
a #ClutterActor child of @layout
whether @actor should fill horizontally the allocated space
whether @actor should fill vertically the allocated space
Retrieves the horizontal and vertical fill policies for @actor
as set using clutter_box_layout_pack() or clutter_box_layout_set_fill()
a #ClutterActor child of @layout
return location for the horizontal fill policy
return location for the vertical fill policy
Sets whether @actor should expand inside @layout
a #ClutterActor child of @layout
whether @actor should expand
Retrieves whether @actor should expand inside @layout
%TRUE if the #ClutterActor should expand, %FALSE otherwise
a #ClutterActor child of @layout
Sets whether @layout should animate changes in the layout properties
The duration of the animations is controlled by
clutter_box_layout_set_easing_duration(); the easing mode to be used
by the animations is controlled by clutter_box_layout_set_easing_mode()
%TRUE if the @layout should use animations
Retrieves whether @layout should animate changes in the layout properties
Since clutter_box_layout_set_use_animations()
%TRUE if the animations should be used, %FALSE otherwise
Sets the easing mode to be used by @layout when animating changes in layout
properties
Use clutter_box_layout_set_use_animations() to enable and disable the
animations
an easing mode, either from #ClutterAnimationMode or a logical id from clutter_alpha_register_func()
Retrieves the easing mode set using clutter_box_layout_set_easing_mode()
an easing mode
Sets the duration of the animations used by @layout when animating changes
in the layout properties
Use clutter_box_layout_set_use_animations() to enable and disable the
animations
the duration of the animations, in milliseconds
Retrieves the duration set using clutter_box_layout_set_easing_duration()
the duration of the animations, in milliseconds
The duration of the animations, in case #ClutterBoxLayout:use-animations
is set to %TRUE
The duration is expressed in milliseconds
The easing mode for the animations, in case
#ClutterBoxLayout:use-animations is set to %TRUE
either be a value from the #ClutterAnimationMode enumeration, like
%CLUTTER_EASE_OUT_CUBIC, or a logical id as returned by
clutter_alpha_register_func()
The default value is %CLUTTER_EASE_OUT_CUBIC
Whether the #ClutterBoxLayout should arrange its children
homogeneously, i.e. all childs get the same size
Whether the #ClutterBoxLayout should pack items at the start
or append them at the end
The spacing between children of the #ClutterBoxLayout, in pixels
Whether the #ClutterBoxLayout should animate changes in the
layout properties
Whether the #ClutterBoxLayout should arrange its children
alongside the Y axis, instead of alongside the X axis
The #ClutterBoxLayoutClass structure contains only private
data and should be accessed using the provided API
Button event.
The event coordinates are relative to the stage that received the
event, and can be transformed into actor-relative coordinates by
using clutter_actor_transform_stage_point().
The #ClutterCairoTexture struct contains only private data.
Creates a new #ClutterCairoTexture actor, with a surface of @width by
the newly created #ClutterCairoTexture actor
the width of the surface
the height of the surface
Creates a new Cairo context that will updat the region defined
by @x_offset, @y_offset, @width and @height.
<warning><para>Do not call this function within the paint virtual
function or from a callback to the #ClutterActor::paint
signal.</para></warning>
to upload the contents of the context when done drawing
a newly created Cairo context. Use cairo_destroy()
offset of the region on the X axis
offset of the region on the Y axis
width of the region, or -1 for the full surface width
height of the region, or -1 for the full surface height
Creates a new Cairo context for the @cairo texture. It is
similar to using clutter_cairo_texture_create_region() with @x_offset
and @y_offset of 0, @width equal to the @cairo texture surface width
and @height equal to the @cairo texture surface height.
<warning><para>Do not call this function within the paint virtual
function or from a callback to the #ClutterActor::paint
signal.</para></warning>
to upload the contents of the context when done drawing
a newly created Cairo context. Use cairo_destroy()
Resizes the Cairo surface used by @self to @width and @height.
the new width of the surface
the new height of the surface
Retrieves the surface width and height for @self.
return location for the surface width, or %NULL
return location for the surface height, or %NULL
Clears @self's internal drawing surface, so that the next upload
will replace the previous contents of the #ClutterCairoTexture
rather than adding to it.
The height of the Cairo surface used by the #ClutterCairoTexture
actor, in pixels.
The width of the Cairo surface used by the #ClutterCairoTexture
actor, in pixels.
The #ClutterCairoTextureClass struct contains only private data.
Generic callback
a #ClutterActor
user data
Base interface for container specific state for child actors. A child
data is meant to be used when you need to keep track of information
about each individual child added to a container.
In order to use it you should create your own subclass of
#ClutterChildMeta and set the #ClutterContainerIface::child_meta_type
interface member to your subclass type, like:
|[
static void
my_container_iface_init (ClutterContainerIface *iface)
{
/* set the rest of the #ClutterContainer vtable */
container_iface->child_meta_type = MY_TYPE_CHILD_META;
}
]|
This will automatically create a #ClutterChildMeta of type
MY_TYPE_CHILD_META for every actor that is added to the container.
The child data for an actor can be retrieved using the
clutter_container_get_child_meta() function.
The properties of the data and your subclass can be manipulated with
clutter_container_child_set() and clutter_container_child_get() which
act like g_object_set() and g_object_get().
You can provide hooks for your own storage as well as control the
instantiation by overriding #ClutterContainerIface::create_child_meta,
#ClutterContainerIface::destroy_child_meta and
#ClutterContainerIface::get_child_meta.
Retrieves the container using @data
a #ClutterContainer
Retrieves the actor wrapped by @data
a #ClutterActor
The #ClutterActor being wrapped by this #ClutterChildMeta
The #ClutterContainer that created this #ClutterChildMeta.
The #ClutterChildMetaClass contains only private data
The <structname>ClutterClickAction</structname> structure contains
only private data and should be accessed using the provided API
Creates a new #ClutterClickAction instance
the newly created #ClutterClickAction
Retrieves the button that was pressed.
the button value
Emulates a release of the pointer button, which ungrabs the pointer
and unsets the #ClutterClickAction:pressed state.
This function is useful to break a grab, for instance after a certain
amount of time has passed.
Whether the clickable actor has the pointer grabbed
Whether the clickable actor should be in "pressed" state
The ::clicked signal is emitted when the #ClutterActor to which
a #ClutterClickAction has been applied should respond to a
pointer button press and release events
the #ClutterActor attached to the @action
The <structname>ClutterClickActionClass</structname> structure
contains only private data
The #ClutterClone structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterActor which clones @source/
the newly created #ClutterClone
a #ClutterActor, or %NULL
Sets @source as the source actor to be cloned by @clone.
a #ClutterActor, or %NULL
Retrieves the source #ClutterActor being cloned by @clone
the actor source for the clone
This property specifies the source actor being cloned.
The #ClutterCloneClass structure contains only private data
Color representation.
Creates a new #ClutterColor with the given values.
when done
the newly allocated color. Use clutter_color_free()
red component of the color, between 0 and 255
green component of the color, between 0 and 255
blue component of the color, between 0 and 255
alpha component of the color, between 0 and 255
Makes a copy of the color structure. The result must be
freed using clutter_color_free().
an allocated copy of @color.
Frees a color structure created with clutter_color_copy().
Adds @a to @b and saves the resulting color inside @result.
The alpha channel of @result is set as as the maximum value
between the alpha channels of @a and @b.
a #ClutterColor
return location for the result
Subtracts @b from @a and saves the resulting color inside @result.
This function assumes that the components of @a are greater than the
components of @b; the result is, otherwise, undefined.
The alpha channel of @result is set as the minimum value
between the alpha channels of @a and @b.
a #ClutterColor
return location for the result
Lightens @color by a fixed amount, and saves the changed color
in @result.
return location for the lighter color
Darkens @color by a fixed amount, and saves the changed color
in @result.
return location for the darker color
Shades @color by @factor and saves the modified color into @result.
the shade factor to apply
return location for the shaded color
Returns a textual specification of @color in the hexadecimal form
<literal>#rrggbbaa</literal>, where <literal>r</literal>,
<literal>g</literal>, <literal>b</literal> and <literal>a</literal> are
hex digits representing the red, green, blue and alpha components
respectively.
a newly-allocated text string
Parses a string definition of a color, filling the
<structfield>red</structfield>, <structfield>green</structfield>,
<structfield>blue</structfield> and <structfield>alpha</structfield>
channels of @color. If alpha is not specified it will be set full opaque.
The @color is not allocated.
The color may be defined by any of the formats understood by
pango_color_from_string(); these include literal color names, like
<literal>Red</literal> or <literal>DarkSlateGray</literal>, or
hexadecimal specifications like <literal>#3050b2</literal> or
<literal>#333</literal>.
%TRUE if parsing succeeded.
a string specifiying a color (named color or #RRGGBBAA)
Converts @color to the HLS format.
The @hue value is in the 0 .. 360 range. The @luminance and
return location for the hue value or %NULL
return location for the luminance value or %NULL
return location for the saturation value or %NULL
Converts a color expressed in HLS (hue, luminance and saturation)
values into a #ClutterColor.
hue value, in the 0 .. 360 range
luminance value, in the 0 .. 1 range
saturation value, in the 0 .. 1 range
Converts @color into a packed 32 bit integer, containing
all the four 8 bit channels used by #ClutterColor.
a packed color
Converts @pixel from the packed representation of a four 8 bit channel
color to a #ClutterColor.
a 32 bit packed integer containing a color
<structname>ClutterColorizeEffect</structname> is an opaque structure
whose members cannot be directly accessed
SinceL 1.4
Creates a new #ClutterColorizeEffect to be used with
clutter_actor_add_effect()
the newly created #ClutterColorizeEffect or %NULL
the color to be used
Sets the tint to be used when colorizing
the color to be used
Retrieves the tint used by @effect
return location for the color used
The tint to apply to the actor
The <structname>ClutterConstraint</structname> structure contains only
private data and should be accessed using the provided API
The <structname>ClutterConstraintClass</structname> structure contains
only private data
#ClutterContainer is an opaque structure whose members cannot be directly
accessed
Calls @callback for each child of @container that was added
by the application (with clutter_container_add_actor()). Does
not iterate over "internal" children that are part of the
container's own implementation, if any.
a function to be called for each child
data to be passed to the function, or %NULL
Calls @callback for each child of @container, including "internal"
children built in to the container itself that were never added
by the application.
a function to be called for each child
data to be passed to the function, or %NULL
Sorts a container's children using their depth. This function should not
be normally used by applications.
Creates the #ClutterChildMeta wrapping @actor inside the
class member is not set to %G_TYPE_INVALID.
This function is only useful when adding a #ClutterActor to
a #ClutterContainer implementation outside of the
#ClutterContainer::add() virtual function implementation.
Applications should not call this function.
a #ClutterActor
Destroys the #ClutterChildMeta wrapping @actor inside the
This function is only useful when removing a #ClutterActor to
a #ClutterContainer implementation outside of the
#ClutterContainer::add() virtual function implementation.
Applications should not call this function.
a #ClutterActor
Retrieves the #ClutterChildMeta which contains the data about the
of @container or %NULL if the specifiec actor does not exist or the
container is not configured to provide #ClutterChildMeta<!-- -->s
the #ClutterChildMeta for the @actor child
a #ClutterActor that is a child of @container.
Adds a list of #ClutterActor<!-- -->s to @container. Each time and
actor is added, the "actor-added" signal is emitted. Each actor should
be parented to @container, which takes a reference on the actor. You
cannot add a #ClutterActor to more than one #ClutterContainer.
the first #ClutterActor to add
Adds a #ClutterActor to @container. This function will emit the
"actor-added" signal. The actor should be parented to
#ClutterContainer.
the first #ClutterActor to add
Removes a %NULL terminated list of #ClutterActor<!-- -->s from
around you must hold a reference to it yourself, using g_object_ref().
Each time an actor is removed, the "actor-removed" signal is
emitted by @container.
first #ClutterActor to remove
Removes @actor from @container. The actor should be unparented, so
if you want to keep it around you must hold a reference to it
yourself, using g_object_ref(). When the actor has been removed,
the "actor-removed" signal is emitted by @container.
a #ClutterActor
Retrieves all the children of @container.
of #ClutterActor<!-- -->s. Use g_list_free() on the returned
list when done.
a list
Calls @callback for each child of @container that was added
by the application (with clutter_container_add_actor()). Does
not iterate over "internal" children that are part of the
container's own implementation, if any.
a function to be called for each child
data to be passed to the function, or %NULL
Calls @callback for each child of @container, including "internal"
children built in to the container itself that were never added
by the application.
a function to be called for each child
data to be passed to the function, or %NULL
Finds a child actor of a container by its name. Search recurses
into any child container.
or %NULL if no actor with that name was found.
The child actor with the requested name,
the name of the requested child.
Raises @actor to @sibling level, in the depth ordering.
the actor to raise
the sibling to raise to, or %NULL to raise to the top
Lowers @actor to @sibling level, in the depth ordering.
the actor to raise
the sibling to lower to, or %NULL to lower to the bottom
Sorts a container's children using their depth. This function should not
be normally used by applications.
Creates the #ClutterChildMeta wrapping @actor inside the
class member is not set to %G_TYPE_INVALID.
This function is only useful when adding a #ClutterActor to
a #ClutterContainer implementation outside of the
#ClutterContainer::add() virtual function implementation.
Applications should not call this function.
a #ClutterActor
Destroys the #ClutterChildMeta wrapping @actor inside the
This function is only useful when removing a #ClutterActor to
a #ClutterContainer implementation outside of the
#ClutterContainer::add() virtual function implementation.
Applications should not call this function.
a #ClutterActor
Retrieves the #ClutterChildMeta which contains the data about the
of @container or %NULL if the specifiec actor does not exist or the
container is not configured to provide #ClutterChildMeta<!-- -->s
the #ClutterChildMeta for the @actor child
a #ClutterActor that is a child of @container.
Sets a container-specific property on a child of @container.
a #ClutterActor that is a child of @container.
the name of the property to set.
the value.
Gets a container specific property of a child of @container, In general,
a copy is made of the property contents and the caller is responsible for
freeing the memory by calling g_value_unset().
Note that clutter_container_child_set_property() is really intended for
language bindings, clutter_container_child_set() is much more convenient
for C programming.
a #ClutterActor that is a child of @container.
the name of the property to set.
the value.
Sets container specific properties on the child of a container.
a #ClutterActor that is a child of @container.
name of the first property to be set.
Gets @container specific properties of an actor.
In general, a copy is made of the property contents and the caller is
responsible for freeing the memory in the appropriate manner for the type, for
instance by calling g_free() or g_object_unref().
a #ClutterActor that is a child of @container.
name of the first property to be set.
The ::actor-added signal is emitted each time an actor
has been added to @container.
the new child that has been added to @container
The ::actor-removed signal is emitted each time an actor
is removed from @container.
the child that has been removed from @container
The ::child-notify signal is emitted each time a property is
being set through the clutter_container_child_set() and
clutter_container_child_set_property() calls.
the child that has had a property set.
Base interface for container actors. The @add, @remove and @foreach
virtual functions must be provided by any implementation; the other
virtual functions are optional.
a function to be called for each child
data to be passed to the function, or %NULL
a function to be called for each child
data to be passed to the function, or %NULL
a #ClutterActor
a #ClutterActor
the #ClutterChildMeta for the @actor child
a #ClutterActor that is a child of @container.
Event for the movement of the pointer across different actors
The <structname>ClutterDeformEffect</structname> structure contains
only private data and should be accessed using the provided API
Sets the material that should be used when drawing the back face
of the actor during a deformation
The #ClutterDeformEffect will take a reference on the material's
handle
a handle to a Cogl material
Retrieves the handle to the back face material used by @effect
The returned material is owned by the #ClutterDeformEffect and it
should not be freed directly
a handle for the material, or %NULL.
Sets the number of horizontal and vertical tiles to be used
when applying the effect
More tiles allow a finer grained deformation at the expenses
of computation
number of horizontal tiles
number of vertical tiles
Retrieves the number of horizontal and vertical tiles used to sub-divide
the actor's geometry during the effect
return location for the number of horizontal tiles, or %NULL
return location for the number of vertical tiles, or %NULL
Invalidates the @effect<!-- -->'s vertices and, if it is associated
to an actor, it will queue a redraw
A material to be used when painting the back of the actor
to which this effect has been applied
By default, no material will be used
The number of horizontal tiles. The bigger the number, the
smaller the tiles
The number of vertical tiles. The bigger the number, the
smaller the tiles
The <structname>ClutterDeformEffectClass</structname> structure contains
only private data
<structname>ClutterDesaturateEffect</structname> is an opaque structure
whose members cannot be directly accessed
Creates a new #ClutterDesaturateEffect to be used with
clutter_actor_add_effect()
the newly created #ClutterDesaturateEffect or %NULL
the desaturation factor, between 0.0 and 1.0
Sets the desaturation factor for @effect, with 0.0 being "do not desaturate"
and 1.0 being "fully desaturate"
the desaturation factor, between 0.0 and 1.0
Retrieves the desaturation factor of @effect
the desaturation factor
The desaturation factor, between 0.0 (no desaturation) and 1.0 (full
desaturation).
The #ClutterDeviceManager structure contains only private data
Retrieves the device manager singleton
The returned instance is owned by Clutter and it should not be
modified or freed
the #ClutterDeviceManager singleton.
Lists all currently registered input devices
a newly allocated list of #ClutterInputDevice objects. Use
g_slist_free() to deallocate it when done
Lists all currently registered input devices
a pointer to the internal list of #ClutterInputDevice objects. The
returned list is owned by the #ClutterDeviceManager and should never
be modified or freed
Retrieves the #ClutterInputDevice with the given @device_id
returned device is owned by the #ClutterDeviceManager and should
never be modified or freed
a #ClutterInputDevice or %NULL. The
the integer id of a device
Retrieves the core #ClutterInputDevice of type @device_type
Core devices are devices created automatically by the default
Clutter backend
returned device is owned by the #ClutterDeviceManager and should
not be modified or freed
a #ClutterInputDevice or %NULL. The
the type of the core device
The ::device-added signal is emitted each time a device has been
added to the #ClutterDeviceManager
the newly added #ClutterInputDevice
The ::device-removed signal is emitted each time a device has been
removed from the #ClutterDeviceManager
the removed #ClutterInputDevice
The #ClutterDeviceManagerClass structure contains only private data
The <structname>ClutterDragAction</structname> structure contains only
private data and should be accessed using the provided API
Creates a new #ClutterDragAction instance
the newly created #ClutterDragAction
Sets the drag threshold that must be cleared by the pointer
before @action can begin the dragging
a distance, in pixels
Retrieves the value set by clutter_drag_action_set_drag_threshold()
the drag threshold value, in pixels
Sets the actor to be used as the drag handle
a #ClutterActor
Retrieves the drag handle set by clutter_drag_action_set_drag_handle()
handle, or %NULL if none was set
a #ClutterActor, used as the drag
Restricts the dragging action to a specific axis
the axis to constraint the dragging to
Retrieves the axis constraint set by clutter_drag_action_set_drag_axis()
the axis constraint
Retrieves the coordinates, in stage space, of the press event
that started the dragging
return location for the press event's X coordinate
return location for the press event's Y coordinate
Retrieves the coordinates, in stage space, of the latest motion
event during the dragging
return location for the latest motion event's X coordinate
return location for the latest motion event's Y coordinate
Constraints the dragging action to the specified axis
The #ClutterActor that is effectively being dragged
A #ClutterDragAction will, be default, use the #ClutterActor that
has been attached to the action; it is possible to create a
separate #ClutterActor and use it instead.
Setting this property has no effect on the #ClutterActor argument
passed to the #ClutterDragAction signals
The threshold, in pixels, that begins a drag action
When set to a non-zero value, #ClutterDragAction will only emit
#ClutterDragAction::drag-begin if the pointer has moved at least
of the given amount of pixels since the button press event
The ::drag-begin signal is emitted when the #ClutterDragAction
starts the dragging
The emission of this signal can be delayed by using the
#ClutterDragAction:drag-threshold property
the #ClutterActor attached to the action
the X coordinate (in stage space) of the press event
the Y coordinate (in stage space) of the press event
the modifiers of the press event
The ::drag-end signal is emitted at the end of the dragging,
when the pointer button's is released
This signal is emitted if and only if the #ClutterDragAction::drag-begin
signal has been emitted first
the #ClutterActor attached to the action
the X coordinate (in stage space) of the release event
the Y coordinate (in stage space) of the release event
the modifiers of the release event
The <structname>ClutterDragActionClass</structname> structure contains
only private data
The axis of the constraint that should be applied on the
dragging action
The #ClutterEffect structure contains only private data and should
be accessed using the provided API
The #ClutterEffectClass structure contains only private data
Creates a new #ClutterEvent of the specified type.
A newly allocated #ClutterEvent.
The type of event.
Puts a copy of the event on the back of the event queue. The event will
have the %CLUTTER_EVENT_FLAG_SYNTHETIC flag set. If the source is set
event signals will be emitted for this source and capture/bubbling for
its ancestors. If the source is not set it will be generated by picking
or use the actor that currently has keyboard focus
Copies @event.
A newly allocated #ClutterEvent
Frees all resources used by @event.
Retrieves the type of the event.
a #ClutterEventType
Retrieves the #ClutterEventFlags of @event
the event flags
Retrieves the time of the event.
the time of the event, or %CLUTTER_CURRENT_TIME
Retrieves the modifier state of the event.
the modifier state parameter, or 0
Retrieves the events device id if set.
no specific device set.
A unique identifier for the device or -1 if the event has
Retrieves the type of the device for @event
any is set
the #ClutterInputDeviceType for the device, if
Retrieves the #ClutterInputDevice for the event.
The #ClutterInputDevice structure is completely opaque and should
be cast to the platform-specific implementation.
the #ClutterInputDevice or %NULL
Retrieves the source #ClutterActor the event originated from, or
NULL if the event has no source.
a #ClutterActor
Retrieves the source #ClutterStage the event originated for, or
%NULL if the event has no stage.
a #ClutterStage
Retrieves the coordinates of @event and puts them into @x and @y.
return location for the X coordinate
return location for the Y coordinate
Retrieves the key symbol of @event
the key symbol representing the key
Retrieves the keycode of the key that caused @event
The keycode representing the key
Retrieves the unicode value for the key that caused @keyev.
The unicode value representing the key
Retrieves the button number of @event
the button number
Retrieves the number of clicks of @event
the click count
Retrieves the related actor of a crossing event.
the related #ClutterActor, or %NULL
Retrieves the direction of the scrolling of @event
the scrolling direction
Flags for the #ClutterEvent
Types of events.
Runtime flags indicating specific features available via Clutter window
sysytem and graphics backend.
The #ClutterFixedLayout structure contains only private data and
it should be accessed using the provided API
Creates a new #ClutterFixedLayout
the newly created #ClutterFixedLayout
The #ClutterFixedLayoutClass structure contains only private data
and it should be accessed using the provided API
The #ClutterFlowLayout structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterFlowLayout with the given @orientation
the newly created #ClutterFlowLayout
the orientation of the flow layout
Sets the orientation of the flow layout
The orientation controls the direction used to allocate
orientation also controls the direction of the overflowing
the orientation of the layout
Retrieves the orientation of the @layout
the orientation of the #ClutterFlowLayout
Sets whether the @layout should allocate the same space for
each child
whether the layout should be homogeneous or not
Retrieves whether the @layout is homogeneous
%TRUE if the #ClutterFlowLayout is homogeneous
Sets the space between columns, in pixels
the space between columns
Retrieves the spacing between columns
in pixels
the spacing between columns of the #ClutterFlowLayout,
Sets the spacing between rows, in pixels
the space between rows
Retrieves the spacing between rows
in pixels
the spacing between rows of the #ClutterFlowLayout,
Sets the minimum and maximum widths that a column can have
minimum width of a column
maximum width of a column
Retrieves the minimum and maximum column widths
return location for the minimum column width, or %NULL
return location for the maximum column width, or %NULL
Sets the minimum and maximum heights that a row can have
the minimum height of a row
the maximum height of a row
Retrieves the minimum and maximum row heights
return location for the minimum row height, or %NULL
return location for the maximum row height, or %NULL
The spacing between columns, in pixels; the value of this
property is honoured by horizontal non-overflowing layouts
and by vertical overflowing layouts
Whether each child inside the #ClutterFlowLayout should receive
the same allocation
Maximum width for each column in the layout, in pixels. If
set to -1 the width will be the maximum child width
Maximum height for each row in the layout, in pixels. If
set to -1 the width will be the maximum child height
Minimum width for each column in the layout, in pixels
Minimum height for each row in the layout, in pixels
The orientation of the #ClutterFlowLayout. The children
of the layout will be layed out following the orientation.
This property also controls the overflowing directions
The spacing between rows, in pixels; the value of this
property is honoured by vertical non-overflowing layouts and
by horizontal overflowing layouts
The #ClutterFlowLayoutClass structure contains only private data
and should be accessed using the provided API
The direction of the arrangement of the children inside
a #ClutterFlowLayout
Fog settings used to create the depth cueing effect.
Runtime flags to change the font quality. To be used with
clutter_set_font_flags().
The rectangle containing an actor's bounding box, measured in pixels.
Find the union of two rectangles represented as #ClutterGeometry.
another #ClutterGeometry
location to store the result
Gravity of the scaling operations. When a gravity different than
%CLUTTER_GRAVITY_NONE is used, an actor is scaled keeping the position
of the specified portion at the same coordinates.
The #ClutterGroup structure contains only private data
and should be accessed using the provided API
Create a new #ClutterGroup.
the newly created #ClutterGroup actor
Gets a groups child held at @index_ in stack.
A Clutter actor, or %NULL if
the position of the requested actor.
Gets the number of actors held in the group.
The number of child actors held in the group.
Removes all children actors from the #ClutterGroup.
The #ClutterGroupClass structure contains only private data
Error conditions returned by clutter_init() and clutter_init_with_args().
Generic representation of an input device. The actual contents of this
structure depend on the backend used.
Retrieves the type of @device
the type of the device
Retrieves the unique identifier of @device
the identifier of the device
Retrieves the latest coordinates of the pointer of @device
return location for the X coordinate
return location for the Y coordinate
Retrieves the #ClutterActor underneath the pointer of @device
a pointer to the #ClutterActor or %NULL
Retrieves the #ClutterStage underneath the pointer of @device
a pointer to the #ClutterStage or %NULL
Retrieves the name of the @device
is owned by the #ClutterInputDevice and should never be modified
or freed
the name of the device, or %NULL. The returned string
Forcibly updates the state of the @device using a #ClutterEvent
for integration with embedding toolkits, like clutter-gtk
Embedding toolkits that disable the event collection inside Clutter
need to use this function to update the state of input devices depending
on a #ClutterEvent that they are going to submit to the event handling code
in Clutter though clutter_do_event(). Since the input devices hold the state
that is going to be used to fill in fields like the #ClutterButtonEvent
click count, or to emit synthesized events like %CLUTTER_ENTER and
%CLUTTER_LEAVE, it is necessary for embedding toolkits to also be
responsible of updating the input device state.
For instance, this might be the code to translate an embedding toolkit
native motion notification into a Clutter #ClutterMotionEvent and ask
Clutter to process it:
|[
ClutterEvent c_event;
translate_native_event_to_clutter (native_event, &c_event);
clutter_do_event (&c_event);
]|
Before letting clutter_do_event() process the event, it is necessary to call
clutter_input_device_update_from_event():
|[
ClutterEvent c_event;
ClutterDeviceManager *manager;
ClutterInputDevice *device;
translate_native_event_to_clutter (native_event, &c_event);
/* get the device manager */
manager = clutter_device_manager_get_default ();
/* use the default Core Pointer that Clutter
* backends register by default
*/
device = clutter_device_manager_get_core_device (manager, %CLUTTER_POINTER_DEVICE);
/* update the state of the input device */
clutter_input_device_update_from_event (device, &c_event, FALSE);
clutter_do_event (&c_event);
]|
The @update_stage boolean argument should be used when the input device
enters and leaves a #ClutterStage; it will use the #ClutterStage field
of the passed @event to update the stage associated to the input device.
a #ClutterEvent
whether to update the #ClutterStage of the @device using the stage of the event
The type of the device
The unique identifier of the device
The name of the device
The #ClutterInputDeviceClass structure contains only private
data and should not be accessed directly
The types of input devices available.
The #ClutterInputDeviceType enumeration can be extended at later
date; not every platform supports every input device type.
The mode of interpolation between key frames
The #ClutterInterval structure contains only private data and should
be accessed using the provided functions.
Creates a new #ClutterInterval holding values of type @gtype.
This function avoids using a #GValue for the initial and final values
of the interval:
|[
interval = clutter_interval_new (G_TYPE_FLOAT, 0.0, 1.0);
interval = clutter_interval_new (G_TYPE_BOOLEAN, FALSE, TRUE);
interval = clutter_interval_new (G_TYPE_INT, 0, 360);
]|
the newly created #ClutterInterval
the type of the values in the interval
Creates a new #ClutterInterval of type @gtype, between @initial
and @final.
This function is useful for language bindings.
the newly created #ClutterInterval
the type of the values in the interval
a #GValue holding the initial value of the interval
a #GValue holding the final value of the interval
Sets the progress function for a given @value_type, like:
|[
clutter_interval_register_progress_func (MY_TYPE_FOO,
my_foo_progress);
]|
Whenever a #ClutterInterval instance using the default
#ClutterInterval::compute_value implementation is set as an
interval between two #GValue of type @value_type, it will call
for instance:
|[
static gboolean
my_int_progress (const GValue *a,
const GValue *b,
gdouble progress,
GValue *retval)
{
gint ia = g_value_get_int (a);
gint ib = g_value_get_int (b);
gint res = factor * (ib - ia) + ia;
g_value_set_int (retval, res);
return TRUE;
}
clutter_interval_register_progress_func (G_TYPE_INT, my_int_progress);
]|
To unset a previously set progress function of a #GType, pass %NULL
for @func.
a #GType
a #ClutterProgressFunc, or %NULL to unset a previously set progress function
Validates the initial and final values of @interval against
a #GParamSpec.
%TRUE if the #ClutterInterval is valid, %FALSE otherwise
a #GParamSpec
Computes the value between the @interval boundaries given the
progress @factor and copies it into @value.
%TRUE if the operation was successful
the progress factor, between 0 and 1
return location for an initialized #GValue
Creates a copy of @interval.
the newly created #ClutterInterval
Retrieves the #GType of the values inside @interval.
the type of the value, or G_TYPE_INVALID
Sets the initial value of @interval to @value. The value is copied
inside the #ClutterInterval.
a #GValue
Retrieves the initial value of @interval and copies
it into @value.
The passed #GValue must be initialized to the value held by
the #ClutterInterval.
a #GValue
Gets the pointer to the initial value of @interval
The value is owned by the #ClutterInterval and it should not be
modified or freed
the initial value of the interval.
Sets the final value of @interval to @value. The value is
copied inside the #ClutterInterval.
a #GValue
Retrieves the final value of @interval and copies
it into @value.
The passed #GValue must be initialized to the value held by
the #ClutterInterval.
a #GValue
Gets the pointer to the final value of @interval
The value is owned by the #ClutterInterval and it should not be
modified or freed
the final value of the interval.
Variable arguments wrapper for clutter_interval_set_initial_value()
and clutter_interval_set_final_value() that avoids using the
#GValue arguments:
|[
clutter_interval_set_interval (interval, 0, 50);
clutter_interval_set_interval (interval, 1.0, 0.0);
clutter_interval_set_interval (interval, FALSE, TRUE);
]|
This function is meant for the convenience of the C API; bindings
should reimplement this function using the #GValue-based API.
Variable arguments wrapper for clutter_interval_get_initial_value()
and clutter_interval_get_final_value() that avoids using the
#GValue arguments:
|[
gint a = 0, b = 0;
clutter_interval_get_interval (interval, &a, &b);
]|
This function is meant for the convenience of the C API; bindings
should reimplement this function using the #GValue-based API.
Validates the initial and final values of @interval against
a #GParamSpec.
%TRUE if the #ClutterInterval is valid, %FALSE otherwise
a #GParamSpec
Computes the value between the @interval boundaries given the
progress @factor and copies it into @value.
%TRUE if the operation was successful
the progress factor, between 0 and 1
return location for an initialized #GValue
Computes the value between the @interval boundaries given the
progress @factor
Unlike clutter_interval_compute_value(), this function will
return a const pointer to the computed value
You should use this function if you immediately pass the computed
value to another function that makes a copy of it, like
g_object_set_property()
or %NULL if the computation was not successfull
a pointer to the computed value,
the progress factor, between 0 and 1
The type of the values in the interval.
The #ClutterIntervalClass contains only private data.
%TRUE if the #ClutterInterval is valid, %FALSE otherwise
a #GParamSpec
%TRUE if the operation was successful
the progress factor, between 0 and 1
return location for an initialized #GValue
Key event
Point in a path behaviour.
Makes an allocated copy of a knot.
the copied knot.
Frees the memory of an allocated knot.
Compares to knot and checks if the point to the same location.
%TRUE if the knots point to the same location.
Second knot
The #ClutterLayoutManager structure contains only private data
and should be accessed using the provided API
Allocates the children of @container given an area
See also clutter_actor_allocate()
the #ClutterContainer using @manager
the #ClutterActorBox containing the allocated area of @container
the allocation flags
If the #ClutterLayoutManager sub-class allows it, allow
adding a weak reference of the @container using @manager
from within the layout manager
The layout manager should not increase the reference
count of the @container
a #ClutterContainer using @manager
Begins an animation of @duration milliseconds, using the provided
easing @mode
The easing mode can be specified either as a #ClutterAnimationMode
or as a logical id returned by clutter_alpha_register_func()
The result of this function depends on the @manager implementation
layout manager; the returned instance is owned by the layout
manager and should not be unreferenced
The #ClutterAlpha created by the
the duration of the animation, in milliseconds
the easing mode of the animation
Retrieves the progress of the animation, if one has been started by
clutter_layout_manager_begin_animation()
The returned value has the same semantics of the #ClutterAlpha:alpha
value
the progress of the animation
Ends an animation started by clutter_layout_manager_begin_animation()
The result of this call depends on the @manager implementation
Computes the minimum and natural widths of the @container according
to @manager.
See also clutter_actor_get_preferred_width()
the #ClutterContainer using @manager
the height for which the width should be computed, or -1
return location for the minimum width of the layout, or %NULL
return location for the natural width of the layout, or %NULL
Computes the minimum and natural heights of the @container according
to @manager.
See also clutter_actor_get_preferred_height()
the #ClutterContainer using @manager
the width for which the height should be computed, or -1
return location for the minimum height of the layout, or %NULL
return location for the natural height of the layout, or %NULL
Allocates the children of @container given an area
See also clutter_actor_allocate()
the #ClutterContainer using @manager
the #ClutterActorBox containing the allocated area of @container
the allocation flags
If the #ClutterLayoutManager sub-class allows it, allow
adding a weak reference of the @container using @manager
from within the layout manager
The layout manager should not increase the reference
count of the @container
a #ClutterContainer using @manager
Emits the #ClutterLayoutManager::layout-changed signal on @manager
This function should only be called by implementations of the
#ClutterLayoutManager class
Retrieves the #GParamSpec for the layout property @name inside
the #ClutterLayoutMeta sub-class used by @manager
or %NULL if no property with that name exists. The returned
#GParamSpec is owned by the layout manager and should not be
modified or freed
a #GParamSpec describing the property,
the name of the property
Retrieves all the #GParamSpec<!-- -->s for the layout properties
stored inside the #ClutterLayoutMeta sub-class used by @manager
array of #GParamSpec<!-- -->s. Use g_free() to free the resources
allocated for the array
the newly-allocated, %NULL-terminated
return location for the number of returned #GParamSpec<!-- -->s
Retrieves the #ClutterLayoutMeta that the layout @manager associated
to the @actor child of @container, eventually by creating one if the
#ClutterLayoutManager supports layout properties
does not have layout properties
a #ClutterLayoutMeta, or %NULL if the #ClutterLayoutManager
a #ClutterContainer using @manager
a #ClutterActor child of @container
Sets a list of properties and their values on the #ClutterLayoutMeta
associated by @manager to a child of @container
Languages bindings should use clutter_layout_manager_child_set_property()
instead
a #ClutterContainer using @manager
a #ClutterActor child of @container
the first property name
Retrieves the values for a list of properties out of the
#ClutterLayoutMeta created by @manager and attached to the
child of a @container
a #ClutterContainer using @manager
a #ClutterActor child of @container
the name of the first property
Sets a property on the #ClutterLayoutMeta created by @manager and
attached to a child of @container
a #ClutterContainer using @manager
a #ClutterActor child of @container
the name of the property to set
a #GValue with the value of the property to set
Gets a property on the #ClutterLayoutMeta created by @manager and
attached to a child of @container
The #GValue must already be initialized to the type of the property
and has to be unset with g_value_unset() after extracting the real
value out of it
a #ClutterContainer using @manager
a #ClutterActor child of @container
the name of the property to get
a #GValue with the value of the property to get
Begins an animation of @duration milliseconds, using the provided
easing @mode
The easing mode can be specified either as a #ClutterAnimationMode
or as a logical id returned by clutter_alpha_register_func()
The result of this function depends on the @manager implementation
layout manager; the returned instance is owned by the layout
manager and should not be unreferenced
The #ClutterAlpha created by the
the duration of the animation, in milliseconds
the easing mode of the animation
Ends an animation started by clutter_layout_manager_begin_animation()
The result of this call depends on the @manager implementation
Retrieves the progress of the animation, if one has been started by
clutter_layout_manager_begin_animation()
The returned value has the same semantics of the #ClutterAlpha:alpha
value
the progress of the animation
The ::layout-changed signal is emitted each time a layout manager
has been changed. Every #ClutterActor using the @manager instance
as a layout manager should connect a handler to the ::layout-changed
signal and queue a relayout on themselves:
|[
static void layout_changed (ClutterLayoutManager *manager,
ClutterActor *self)
{
clutter_actor_queue_relayout (self);
}
...
self->manager = g_object_ref_sink (manager);
g_signal_connect (self->manager, "layout-changed",
G_CALLBACK (layout_changed),
self);
]|
Sub-classes of #ClutterLayoutManager that implement a layout that
can be controlled or changed using parameters should emit the
::layout-changed signal whenever one of the parameters changes,
by using clutter_layout_manager_layout_changed().
The #ClutterLayoutManagerClass structure contains only private
data and should be accessed using the provided API
the #ClutterContainer using @manager
the #ClutterActorBox containing the allocated area of @container
the allocation flags
a #ClutterContainer using @manager
The #ClutterAlpha created by the
the duration of the animation, in milliseconds
the easing mode of the animation
the progress of the animation
Retrieves the actor wrapped by @data
a #ClutterLayoutManager
The #ClutterLayoutManager that created this #ClutterLayoutMeta.
The #ClutterLayoutMetaClass contains only private data and
should never be accessed directly
The #ClutterListModel struct contains only private data.
Creates a new default model with @n_columns columns with the types
and names passed in.
For example:
<informalexample><programlisting>
model = clutter_list_model_new (3,
G_TYPE_INT, "Score",
G_TYPE_STRING, "Team",
GDK_TYPE_PIXBUF, "Logo");
</programlisting></informalexample>
will create a new #ClutterModel with three columns of type int,
string and #GdkPixbuf respectively.
Note that the name of the column can be set to %NULL, in which case
the canonical name of the type held by the column will be used as
the title.
a new #ClutterListModel
number of columns in the model
Non-vararg version of clutter_list_model_new(). This function is
useful for language bindings.
a new default #ClutterModel
number of columns in the model
an array of #GType types for the columns, from first to last
an array of names for the columns, from first to last
The #ClutterListModelClass struct contains only private data.
#ClutterMedia is an opaque structure whose members cannot be directly
accessed
Sets the URI of @media to @uri.
the URI of the media stream
Retrieves the URI from @media.
to free the returned string
the URI of the media stream. Use g_free()
Sets the source of @media using a file path.
A filename
Starts or stops playing of @media.
%TRUE to start playing
Retrieves the playing status of @media.
%TRUE if playing, %FALSE if stopped.
Sets the playback progress of @media. The @progress is
a normalized value between 0.0 (begin) and 1.0 (end).
the progress of the playback, between 0.0 and 1.0
Retrieves the playback progress of @media.
the playback progress, between 0.0 and 1.0
Sets the location of a subtitle file to display while playing @media.
the URI of a subtitle file
Retrieves the URI of the subtitle file in use.
to free the returned string
the URI of the subtitle file. Use g_free()
Sets the font used by the subtitle renderer. The @font_name string must be
either %NULL, which means that the default font name of the underlying
implementation will be used; or must follow the grammar recognized by
pango_font_description_from_string() like:
|[
clutter_media_set_subtitle_font_name (media, "Sans 24pt");
]|
a font name, or %NULL to set the default font name
Retrieves the font name currently used.
to free the returned string
a string containing the font name. Use g_free()
Sets the playback volume of @media to @volume.
the volume as a double between 0.0 and 1.0
Retrieves the playback volume of @media.
The playback volume between 0.0 and 1.0
Retrieves whether @media is seekable or not.
%TRUE if @media can seek, %FALSE otherwise.
Retrieves the amount of the stream that is buffered.
the fill level, between 0.0 and 1.0
Retrieves the duration of the media stream that @media represents.
the duration of the media stream, in seconds
The volume of the audio, as a normalized value between
0.0 and 1.0.
The fill level of the buffer for the current stream,
as a value between 0.0 and 1.0.
Whether the current stream is seekable.
The duration of the current stream, in seconds
Whether the #ClutterMedia actor is playing.
The current progress of the playback, as a normalized
value between 0.0 and 1.0.
The font used to display subtitles. The font description has to
follow the same grammar as the one recognized by
pango_font_description_from_string().
The location of a subtitle file, expressed as a valid URI.
The location of a media file, expressed as a valid URI.
The ::eos signal is emitted each time the media stream ends.
The ::error signal is emitted each time an error occurred.
the #GError
Interface vtable for #ClutterMedia implementations
Base class for list models. The #ClutterModel structure contains
only private data and should be manipulated using the provided
API.
Retrieves the number of rows inside @model, eventually taking
into account any filtering function set using clutter_model_set_filter().
the length of the filtered @model is returned.
The length of the @model. If there is a filter set, then
Retrieves the number of columns inside @model.
the number of columns
Retrieves the name of the @column
string, and it should not be modified or freed
the name of the column. The model holds the returned
the column number
Retrieves the type of the @column.
the type of the column.
the column number
Retrieves a #ClutterModelIter representing the row at the given index.
If a filter function has been set using clutter_model_set_filter()
then the @model implementation will return the first non filtered
row.
out of bounds. When done using the iterator object, call g_object_unref()
to deallocate its resources
A new #ClutterModelIter, or %NULL if @row was
position of the row to retrieve
Sets the types of the columns inside a #ClutterModel.
This function is meant primarily for #GObjects that inherit from
#ClutterModel, and should only be used when contructing a #ClutterModel.
It will not work after the initial creation of the #ClutterModel.
number of columns for the model
an array of #GType types
Assigns a name to the columns of a #ClutterModel.
This function is meant primarily for #GObjects that inherit from
#ClutterModel, and should only be used when contructing a #ClutterModel.
It will not work after the initial creation of the #ClutterModel.
the number of column names
an array of strings
Creates and appends a new row to the #ClutterModel, setting the
row values upon creation. For example, to append a new row where
column 0 is type %G_TYPE_INT and column 1 is of type %G_TYPE_STRING:
<informalexample><programlisting>
ClutterModel *model;
model = clutter_model_default_new (2,
G_TYPE_INT, "Score",
G_TYPE_STRING, "Team");
clutter_model_append (model, 0, 42, 1, "Team #1", -1);
</programlisting></informalexample>
Creates and appends a new row to the #ClutterModel, setting the row
values for the given @columns upon creation.
the number of columns and values
a vector with the columns to set
a vector with the values
Creates and prepends a new row to the #ClutterModel, setting the row
values upon creation. For example, to prepend a new row where column 0
is type %G_TYPE_INT and column 1 is of type %G_TYPE_STRING:
<informalexample><programlisting>
ClutterModel *model;
model = clutter_model_default_new (2,
G_TYPE_INT, "Score",
G_TYPE_STRING, "Team");
clutter_model_prepend (model, 0, 42, 1, "Team #1", -1);
</programlisting></informalexample>
Creates and prepends a new row to the #ClutterModel, setting the row
values for the given @columns upon creation.
the number of columns and values to set
a vector containing the columns to set
a vector containing the values for the cells
Inserts a new row to the #ClutterModel at @row, setting the row
values upon creation. For example, to insert a new row at index 100,
where column 0 is type %G_TYPE_INT and column 1 is of type
%G_TYPE_STRING:
<informalexample><programlisting>
ClutterModel *model;
model = clutter_model_default_new (2,
G_TYPE_INT, "Score",
G_TYPE_STRING, "Team");
clutter_model_insert (model, 3, 0, 42, 1, "Team #1", -1);
</programlisting></informalexample>
the position to insert the new row
Inserts data at @row into the #ClutterModel, setting the row
values for the given @columns upon creation.
row index
the number of columns and values to set
a vector containing the columns to set
a vector containing the values for the cells
Sets the data in the cell specified by @iter and @column. The type of
not exist then it is created.
position of the row to modify
column to modify
new value for the cell
Removes the row at the given position from the model.
position of row to remove
Retrieves the number of rows inside @model, eventually taking
into account any filtering function set using clutter_model_set_filter().
the length of the filtered @model is returned.
The length of the @model. If there is a filter set, then
Retrieves the number of columns inside @model.
the number of columns
Retrieves the name of the @column
string, and it should not be modified or freed
the name of the column. The model holds the returned
the column number
Retrieves the type of the @column.
the type of the column.
the column number
Retrieves a #ClutterModelIter representing the first non-filtered
row in @model.
Call g_object_unref() when done using it
A new #ClutterModelIter.
Retrieves a #ClutterModelIter representing the last non-filtered
row in @model.
Call g_object_unref() when done using it
A new #ClutterModelIter.
Retrieves a #ClutterModelIter representing the row at the given index.
If a filter function has been set using clutter_model_set_filter()
then the @model implementation will return the first non filtered
row.
out of bounds. When done using the iterator object, call g_object_unref()
to deallocate its resources
A new #ClutterModelIter, or %NULL if @row was
position of the row to retrieve
Sets the model to sort by @column. If @column is a negative value
the sorting column will be unset.
the column of the @model to sort, or -1
Retrieves the number of column used for sorting the @model.
a column number, or -1 if the model is not sorted
Calls @func for each row in the model.
a #ClutterModelForeachFunc
user data to pass to @func
Sorts @model using the given sorting function.
the column to sort on
a #ClutterModelSortFunc, or #NULL
user data to pass to @func, or #NULL
destroy notifier of @user_data, or #NULL
Filters the @model using the given filtering function.
a #ClutterModelFilterFunc, or #NULL
user data to pass to @func, or #NULL
destroy notifier of @user_data, or #NULL
Returns whether the @model has a filter in place, set
using clutter_model_set_filter()
%TRUE if a filter is set
Force a resort on the @model. This function should only be
used by subclasses of #ClutterModel.
Checks whether @row should be filtered or not using the
filtering function set on @model.
This function should be used only by subclasses of #ClutterModel.
%FALSE otherwise
%TRUE if the row should be displayed,
the row to filter
Checks whether the row pointer by @iter should be filtered or not using
the filtering function set on @model.
This function should be used only by subclasses of #ClutterModel.
%FALSE otherwise
%TRUE if the row should be displayed,
the row to filter
Whether the #ClutterModel has a filter set
This property is set to %TRUE if a filter function has been
set using clutter_model_set_filter()
The ::filter-changed signal is emitted when a new filter has been applied
The ::row-added signal is emitted when a new row has been added.
The data on the row has already been set when the ::row-added signal
has been emitted.
a #ClutterModelIter pointing to the new row
The ::row-removed signal is emitted when a row has been changed.
The data on the row has already been updated when the ::row-changed
signal has been emitted.
a #ClutterModelIter pointing to the changed row
The ::row-removed signal is emitted when a row has been removed.
The data on the row pointed by the passed iterator is still valid
when the ::row-removed signal has been emitted.
a #ClutterModelIter pointing to the removed row
The ::sort-changed signal is emitted after the model has been sorted
Class for #ClutterModel instances.
The length of the @model. If there is a filter set, then
the number of columns
the name of the column. The model holds the returned
the column number
the type of the column.
the column number
A new #ClutterModelIter, or %NULL if @row was
position of the row to retrieve
Filters the content of a row in the model.
If the row should be displayed, return %TRUE
a #ClutterModel
the iterator for the row
data passed to clutter_model_set_filter()
Iterates on the content of a row in the model
%TRUE if the iteration should continue, %FALSE otherwise
a #ClutterModel
the iterator for the row
data passed to clutter_model_foreach()
Base class for list models iters. The #ClutterModelIter structure
contains only private data and should be manipulated using the
provided API.
Sets an initializes @value to that at @column. When done with @value,
g_value_unset() needs to be called to free any allocated memory.
column number to retrieve the value from
an empty #GValue to set
Sets the data in the cell specified by @iter and @column. The type of
column number to retrieve the value from
new value for the cell
Gets whether the current iterator is at the beginning of the model
to which it belongs.
#TRUE if @iter is the first iter in the filtered model
Gets whether the iterator is at the end of the model to which it
belongs.
#TRUE if @iter is the last iter in the filtered model.
Updates the @iter to point at the next position in the model.
The model implementation should take into account the presence of
a filter function.
row in the model.
The passed iterator, updated to point at the next
Sets the @iter to point at the previous position in the model.
The model implementation should take into account the presence of
a filter function.
row in the model.
The passed iterator, updated to point at the previous
Retrieves a pointer to the #ClutterModel that this iter is part of.
a pointer to a #ClutterModel.
Retrieves the position of the row that the @iter points to.
the position of the @iter in the model
Copies the passed iterator.
a copy of the iterator, or %NULL
Gets the value of one or more cells in the row referenced by @iter. The
variable argument list should contain integer column numbers, each column
column number followed by a place to store the value being retrieved. The
list is terminated by a -1.
For example, to get a value from column 0 with type %G_TYPE_STRING use:
<informalexample><programlisting>
clutter_model_iter_get (iter, 0, &place_string_here, -1);
</programlisting></informalexample>
where place_string_here is a gchar* to be filled with the string. If
appropriate, the returned values have to be freed or unreferenced.
Sets an initializes @value to that at @column. When done with @value,
g_value_unset() needs to be called to free any allocated memory.
column number to retrieve the value from
an empty #GValue to set
Sets the value of one or more cells in the row referenced by @iter. The
variable argument list should contain integer column numbers, each column
column number followed by the value to be set. The list is terminated by a
-1.
For example, to set column 0 with type %G_TYPE_STRING, use:
<informalexample><programlisting>
clutter_model_iter_set (iter, 0, "foo", -1);
</programlisting></informalexample>
Sets the data in the cell specified by @iter and @column. The type of
column number to retrieve the value from
new value for the cell
Gets whether the current iterator is at the beginning of the model
to which it belongs.
#TRUE if @iter is the first iter in the filtered model
Gets whether the iterator is at the end of the model to which it
belongs.
#TRUE if @iter is the last iter in the filtered model.
Updates the @iter to point at the next position in the model.
The model implementation should take into account the presence of
a filter function.
row in the model.
The passed iterator, updated to point at the next
Sets the @iter to point at the previous position in the model.
The model implementation should take into account the presence of
a filter function.
row in the model.
The passed iterator, updated to point at the previous
Retrieves a pointer to the #ClutterModel that this iter is part of.
a pointer to a #ClutterModel.
Retrieves the position of the row that the @iter points to.
the position of the @iter in the model
Copies the passed iterator.
a copy of the iterator, or %NULL
A reference to the #ClutterModel that this iter belongs to.
The row number to which this iter points to.
Class for #ClutterModelIter instances.
column number to retrieve the value from
an empty #GValue to set
column number to retrieve the value from
new value for the cell
#TRUE if @iter is the first iter in the filtered model
#TRUE if @iter is the last iter in the filtered model.
The passed iterator, updated to point at the next
The passed iterator, updated to point at the previous
a pointer to a #ClutterModel.
the position of the @iter in the model
a copy of the iterator, or %NULL
Compares the content of two rows in the model.
a positive integer if @a is after @b, a negative integer if
a #ClutterModel
a #GValue representing the contents of the row
a #GValue representing the contents of the second row
data passed to clutter_model_set_sort()
Masks applied to a #ClutterEvent by modifiers.
Event for the pointer motion
The #ClutterOffscreenEffect structure contains only private data
and should be accessed using the provided API
Calls the paint_target() virtual function of the @effect
Retrieves the material used as a render target for the offscreen
buffer created by @effect
%COGL_INVALID_HANDLE. The returned handle is owned by Clutter
and it should not be modified or freed
a handle for a #CoglMaterial, or
Calls the paint_target() virtual function of the @effect
Calls the create_target() virtual function of the @effect
a handle to the target texture
the minimum width of the target texture
the minimum height of the target texture
The #ClutterOffscreenEffectClass structure contains only private data
<structname>ClutterPageTurnEffect</structname> is an opaque structure
whose members can only be accessed using the provided API
Creates a new #ClutterPageTurnEffect instance with the given parameters
the newly created #ClutterPageTurnEffect
the period of the page curl, between 0.0 and 1.0
the angle of the page curl, between 0.0 and 360.0
the radius of the page curl, in pixels
Sets the period of the page curling, between 0.0 (no curling)
and 1.0 (fully curled)
the period of the page curl, between 0.0 and 1.0
Retrieves the value set using clutter_page_turn_effect_get_period()
the period of the page curling
Sets the angle of the page curling, in degrees
the angle of the page curl, in degrees
Retrieves the value set using clutter_page_turn_effect_get_angle()
the angle of the page curling
Sets the radius of the page curling
the radius of the page curling, in pixels
Retrieves the value set using clutter_page_turn_effect_set_radius()
the radius of the page curling
The angle of the page rotation, in degrees, between 0.0 and 360.0
The period of the page turn, between 0.0 (no curling) and
1.0 (fully curled)
The radius of the page curl, in pixels
A #GParamSpec subclass for defining properties holding
a #ClutterColor.
#GParamSpec subclass for unit based properties.
The #ClutterPath struct contains only private data and should
be accessed with the functions below.
Creates a new #ClutterPath instance with no nodes.
The object has a floating reference so if you add it to a
#ClutterBehaviourPath then you do not need to unref it.
the newly created #ClutterPath
Creates a new #ClutterPath instance with the nodes described in
the string.
The object has a floating reference so if you add it to a
#ClutterBehaviourPath then you do not need to unref it.
the newly created #ClutterPath
a string describing the path
Adds a %CLUTTER_PATH_MOVE_TO type node to the path. This is usually
used as the first node in a path. It can also be used in the middle
of the path to cause the actor to jump to the new coordinate.
the x coordinate
the y coordinate
Same as clutter_path_add_move_to() except the coordinates are
relative to the previous node.
the x coordinate
the y coordinate
Adds a %CLUTTER_PATH_LINE_TO type node to the path. This causes the
actor to move to the new coordinates in a straight line.
the x coordinate
the y coordinate
Same as clutter_path_add_line_to() except the coordinates are
relative to the previous node.
the x coordinate
the y coordinate
Adds a %CLUTTER_PATH_CURVE_TO type node to the path. This causes
the actor to follow a bezier from the last node to (@x_3, @y_3) using
(@x_1, @y_1) and (@x_2,@y_2) as control points.
the x coordinate of the first control point
the y coordinate of the first control point
the x coordinate of the second control point
the y coordinate of the second control point
the x coordinate of the third control point
the y coordinate of the third control point
Same as clutter_path_add_curve_to() except the coordinates are
relative to the previous node.
the x coordinate of the first control point
the y coordinate of the first control point
the x coordinate of the second control point
the y coordinate of the second control point
the x coordinate of the third control point
the y coordinate of the third control point
Adds a %CLUTTER_PATH_CLOSE type node to the path. This creates a
straight line from the last node to the last %CLUTTER_PATH_MOVE_TO
type node.
Adds new nodes to the end of the path as described in @str. The
format is a subset of the SVG path format. Each node is represented
by a letter and is followed by zero, one or three pairs of
coordinates. The coordinates can be separated by spaces or a
comma. The types are:
<variablelist>
<varlistentry><term>M</term>
<listitem><para>
Adds a %CLUTTER_PATH_MOVE_TO node. Takes one pair of coordinates.
</para></listitem></varlistentry>
<varlistentry><term>L</term>
<listitem><para>
Adds a %CLUTTER_PATH_LINE_TO node. Takes one pair of coordinates.
</para></listitem></varlistentry>
<varlistentry><term>C</term>
<listitem><para>
Adds a %CLUTTER_PATH_CURVE_TO node. Takes three pairs of coordinates.
</para></listitem></varlistentry>
<varlistentry><term>z</term>
<listitem><para>
Adds a %CLUTTER_PATH_CLOSE node. No coordinates are needed.
</para></listitem></varlistentry>
</variablelist>
The M, L and C commands can also be specified in lower case which
means the coordinates are relative to the previous node.
For example, to move an actor in a 100 by 100 pixel square centered
on the point 300,300 you could use the following path:
<informalexample>
<programlisting>
M 250,350 l 0 -100 L 350,250 l 0 100 z
</programlisting>
</informalexample>
If the path description isn't valid %FALSE will be returned and no
nodes will be added.
otherwise.
%TRUE is the path description was valid or %FALSE
a string describing the new nodes
Adds @node to the end of the path.
a #ClutterPathNode
Add the nodes of the Cairo path to the end of @path.
a Cairo path
Retrieves the number of nodes in the path.
the number of nodes.
Retrieves the node of the path indexed by @index.
the node number to retrieve
a location to store a copy of the node
Returns a #GSList of #ClutterPathNode<!-- -->s. The list should be
freed with g_slist_free(). The nodes are owned by the path and
should not be freed. Altering the path may cause the nodes in the
list to become invalid so you should copy them if you want to keep
the list.
a list of nodes in the path.
Calls a function for each node of the path.
the function to call with each node
user data to pass to the function
Inserts @node into the path before the node at the given offset. If
offset of where to insert the node
the node to insert
Removes the node at the given offset from the path.
index of the node to remove
Replaces the node at offset @index_ with @node.
index to the existing node
the replacement node
Returns a newly allocated string describing the path in the same
format as used by clutter_path_add_string().
a string description of the path. Free with g_free().
Replaces all of the nodes in the path with nodes described by
If the string is invalid then %FALSE is returned and the path is
unaltered.
%TRUE is the path was valid, %FALSE otherwise.
a string describing the path
Removes all nodes from the path.
Add the nodes of the ClutterPath to the path in the Cairo context.
a Cairo context
The value in @progress represents a position along the path where
0.0 is the beginning and 1.0 is the end of the path. An
interpolated position is then stored in @position.
index of the node used to calculate the position.
a position along the path as a fraction of its length
location to store the position
Retrieves an approximation of the total length of the path.
the length of the path.
This function is passed to clutter_path_foreach() and will be
called for each node contained in the path.
the node
optional data passed to the function
The #ClutterPathClass struct contains only private data.
Represents a single node of a #ClutterPath.
Some of the coordinates in @points may be unused for some node
types. %CLUTTER_PATH_MOVE_TO and %CLUTTER_PATH_LINE_TO use only one
pair of coordinates, %CLUTTER_PATH_CURVE_TO uses all three and
%CLUTTER_PATH_CLOSE uses none.
Makes an allocated copy of a node.
the copied node.
Frees the memory of an allocated node.
Compares two nodes and checks if they are the same type with the
same coordinates.
%TRUE if the nodes are the same.
Second node
Types of nodes in a #ClutterPath.
Stage perspective definition. #ClutterPerspective is only used by
the fixed point version of clutter_stage_set_perspective().
Controls the paint cycle of the scene graph when in pick mode
Prototype of the progress function used to compute the value
between the two ends @a and @b of an interval depending on
the value of @progress.
The #GValue in @retval is already initialized with the same
type as @a and @b.
This function will be called by #ClutterInterval if the
type of the values of the interval was registered using
clutter_interval_register_progress_func().
the value and stored it inside @retval
%TRUE if the function successfully computed
the initial value of an interval
the final value of an interval
the progress factor, between 0 and 1
the value used to store the progress
The #ClutterRectangle structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterActor with a rectangular shape.
a new #ClutterActor
Creates a new #ClutterActor with a rectangular shape
and of the given @color.
a new #ClutterActor
a #ClutterColor
Retrieves the color of @rectangle.
return location for a #ClutterColor
Sets the color of @rectangle.
a #ClutterColor
Gets the width (in pixels) of the border used by @rectangle
the border's width
Sets the width (in pixel) of the border used by @rectangle.
A @width of 0 will unset the border.
the width of the border
Gets the color of the border used by @rectangle and places
it into @color.
return location for a #ClutterColor
Sets the color of the border used by @rectangle using @color
the color of the border
The color of the border of the rectangle.
The width of the border of the rectangle, in pixels.
The color of the rectangle.
Whether the #ClutterRectangle should be displayed with a border.
The #ClutterRectangleClass structure contains only private data
Flags passed to the clutter_actor_queue_redraw_with_clip ()
function
Specifies the type of requests for a #ClutterActor.
Axis of a rotation.
Direction of a rotation.
The #ClutterScore structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterScore. A #ClutterScore is an object that can
hold multiple #ClutterTimeline<!-- -->s in a sequential order.
when done.
the newly created #ClutterScore. Use g_object_unref()
Sets whether @score should loop. A looping #ClutterScore will start
from its initial state after the ::complete signal has been fired.
%TRUE for enable looping
Gets whether @score is looping
%TRUE if the score is looping
Appends a timeline to another one existing in the score; the newly
appended timeline will be started when @parent is complete.
If @parent is %NULL, the new #ClutterTimeline will be started when
clutter_score_start() is called.
#ClutterScore will take a reference on @timeline.
0 on failure. The returned id can be used with clutter_score_remove()
or clutter_score_get_timeline().
the id of the #ClutterTimeline inside the score, or
a #ClutterTimeline in the score, or %NULL
a #ClutterTimeline
Appends @timeline at the given @marker_name on the @parent
#ClutterTimeline.
If you want to append @timeline at the end of @parent, use
clutter_score_append().
The #ClutterScore will take a reference on @timeline.
0 on failure. The returned id can be used with clutter_score_remove()
or clutter_score_get_timeline().
the id of the #ClutterTimeline inside the score, or
the parent #ClutterTimeline
the name of the marker to use
the #ClutterTimeline to append
Removes the #ClutterTimeline with the given id inside @score. If
the timeline has other timelines attached to it, those are removed
as well.
the id of the timeline to remove
Removes all the timelines inside @score.
Retrieves the #ClutterTimeline for @id inside @score.
function does not increase the reference count on the returned
#ClutterTimeline
the requested timeline, or %NULL. This
the id of the timeline
Retrieves a list of all the #ClutterTimelines managed by @score.
containing all the timelines in the score. This function does not increase
the reference count of the returned timelines. Use g_slist_free() on the
returned list to deallocate its resources.
a #GSList
Starts the score.
Stops and rewinds a playing #ClutterScore instance.
Pauses a playing score @score.
Rewinds a #ClutterScore to its initial state.
Query state of a #ClutterScore instance.
%TRUE if score is currently playing
Whether the #ClutterScore should restart once finished.
The ::completed signal is emitted each time a #ClutterScore terminates.
The ::paused signal is emitted each time a #ClutterScore
is paused.
The ::started signal is emitted each time a #ClutterScore starts playing.
The ::timeline-completed signal is emitted each time a timeline
inside a #ClutterScore terminates.
the completed timeline
The ::timeline-started signal is emitted each time a new timeline
inside a #ClutterScore starts playing.
the current timeline
The #ClutterScoreClass structure contains only private data
The #ClutterScript structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterScript instance. #ClutterScript can be used
to load objects definitions for scenegraph elements, like actors,
or behavioural elements, like behaviours and timelines. The
definitions must be encoded using the JavaScript Object Notation (JSON)
language.
g_object_unref() when done.
the newly created #ClutterScript instance. Use
Looks up a type by name, using the virtual function that
#ClutterScript has for that purpose. This function should
rarely be used.
%G_TYPE_INVALID if not corresponding type was found.
the type for the requested type name, or
name of the type to look up
Loads the definitions from @filename into @script and merges with
the currently loaded ones, if any.
accordingly. On success, the merge id for the UI definitions is
returned. You can use the merge id with clutter_script_unmerge_objects().
on error, zero is returned and @error is set
the full path to the definition file
Loads the definitions from @data into @script and merges with
the currently loaded ones, if any.
accordingly. On success, the merge id for the UI definitions is
returned. You can use the merge id with clutter_script_unmerge().
on error, zero is returned and @error is set
a buffer containing the definitions
the length of the buffer, or -1 if @data is a NUL-terminated buffer
Retrieves the object bound to @name. This function does not increment
the reference count of the returned object.
with the given name was available
the named object, or %NULL if no object
the name of the object to retrieve
Retrieves a list of objects for the given names. After @script, object
names/return location pairs should be listed, with a %NULL pointer
ending the list, like:
<informalexample><programlisting>
GObject *my_label, *a_button, *main_timeline;
clutter_script_get_objects (script,
"my-label", &my_label,
"a-button", &a_button,
"main-timeline", &main_timeline,
NULL);
</programlisting></informalexample>
returned objects.
the number of objects returned.
the name of the first object to retrieve
Retrieves all the objects created by @script.
objects it returns.
or %NULL. The objects are owned by the #ClutterScript instance. Use g_list_free() on the
returned value when done.
a list of #GObject<!-- -->s,
Unmerges the objects identified by @merge_id.
merge id returned when loading a UI definition
Ensure that every object defined inside @script is correctly
constructed. You should rarely need to use this function.
Looks up a type by name, using the virtual function that
#ClutterScript has for that purpose. This function should
rarely be used.
%G_TYPE_INVALID if not corresponding type was found.
the type for the requested type name, or
name of the type to look up
Connects all the signals defined into a UI definition file to their
handlers.
This method invokes clutter_script_connect_signals_full() internally
and uses #GModule's introspective features (by opening the current
module's scope) to look at the application's symbol table.
Note that this function will not work if #GModule is not supported by
the platform Clutter is running on.
data to be passed to the signal handlers, or %NULL
Connects all the signals defined into a UI definition file to their
handlers.
This function allows to control how the signal handlers are
going to be connected to their respective signals. It is meant
primarily for language bindings to allow resolving the function
names using the native API.
Applications should use clutter_script_connect_signals().
signal connection function
data to be passed to the signal handlers, or %NULL
Adds @paths to the list of search paths held by @script.
The search paths are used by clutter_script_lookup_filename(), which
can be used to define search paths for the textures source file name
or other custom, file-based properties.
an array of strings containing different search paths
the length of the passed array
Looks up @filename inside the search paths of @script. If @filename
is found, its full path will be returned .
found.
the full path of @filename or %NULL if no path was
the name of the file to lookup
The path of the currently parsed file. If #ClutterScript:filename-set
is %FALSE then the value of this property is undefined.
Whether the #ClutterScript:filename property is set. If this property
is %TRUE then the currently parsed data comes from a file, and the
file name is stored inside the #ClutterScript:filename property.
The #ClutterScriptClass structure contains only private data
the type for the requested type name, or
name of the type to look up
This is the signature of a function used to connect signals. It is used
by the clutter_script_connect_signals_full() function. It is mainly
intended for interpreted language bindings, but could be useful where the
programmer wants more control over the signal connection process.
a #ClutterScript
the object to connect
the name of the signal
the name of the signal handler
the object to connect the signal to, or %NULL
signal connection flags
user data to pass to the signal handler
#ClutterScript error enumeration.
#ClutterScriptable is an opaque structure whose members cannot be directly
accessed
Retrieves the id of @scriptable set using clutter_scriptable_set_id().
the scriptable object and should never be modified of freed
the id of the object. The returned string is owned by
Parses the passed JSON node. The implementation must set the type
of the passed #GValue pointer using g_value_init().
%TRUE if the node was successfully parsed, %FALSE otherwise.
the #ClutterScript creating the scriptable instance
the generic value to be set
the name of the node
the JSON node to be parsed
Overrides the common properties setting. The underlying virtual
function should be used when implementing custom properties.
the #ClutterScript creating the scriptable instance
the name of the property
the value of the property
Sets @id as the unique Clutter script it for this instance of
#ClutterScriptableIface.
This name can be used by user interface designer applications to
define a unique name for an object constructable using the UI
definition language parsed by #ClutterScript.
the #ClutterScript id of the object
Retrieves the id of @scriptable set using clutter_scriptable_set_id().
the scriptable object and should never be modified of freed
the id of the object. The returned string is owned by
Parses the passed JSON node. The implementation must set the type
of the passed #GValue pointer using g_value_init().
%TRUE if the node was successfully parsed, %FALSE otherwise.
the #ClutterScript creating the scriptable instance
the generic value to be set
the name of the node
the JSON node to be parsed
Overrides the common properties setting. The underlying virtual
function should be used when implementing custom properties.
the #ClutterScript creating the scriptable instance
the name of the property
the value of the property
Interface for implementing "scriptable" objects. An object implementing
this interface can override the parsing and properties setting sequence
when loading a UI definition data with #ClutterScript
the id of the object. The returned string is owned by
%TRUE if the node was successfully parsed, %FALSE otherwise.
the #ClutterScript creating the scriptable instance
the generic value to be set
the name of the node
the JSON node to be parsed
the #ClutterScript creating the scriptable instance
the name of the property
the value of the property
Direction of a pointer scroll event.
Scroll wheel (or similar device) event
<structname>ClutterSettings</structname> is an opaque structure whose
members cannot be directly accessed.
Retrieves the singleton instance of #ClutterSettings
returned object is owned by Clutter and it should not be unreferenced
directly
the instance of #ClutterSettings. The
A back pointer to the #ClutterBackend
The maximum distance, in pixels, between button-press events that
determines whether or not to increase the click count by 1.
The time, in milliseconds, that should elapse between button-press
events in order to increase the click count by 1.
Whether or not to use antialiasing when rendering text; a value
of 1 enables it unconditionally; a value of 0 disables it
unconditionally; and -1 will use the system's default.
The DPI used when rendering text, as a value of 1024 * dots/inch.
If set to -1, the system's default will be used instead
The style of the hinting used when rendering text. Valid values
are:
<itemizedlist>
<listitem><simpara>hintnone</simpara></listitem>
<listitem><simpara>hintslight</simpara></listitem>
<listitem><simpara>hintmedium</simpara></listitem>
<listitem><simpara>hintfull</simpara></listitem>
</itemizedlist>
Whether or not to use hinting when rendering text; a value of 1
unconditionally enables it; a value of 0 unconditionally disables
it; and a value of -1 will use the system's default.
The default font name that should be used by text actors, as
a string that can be passed to pango_font_description_from_string().
The type of sub-pixel antialiasing used when rendering text. Valid
values are:
<itemizedlist>
<listitem><simpara>none</simpara></listitem>
<listitem><simpara>rgb</simpara></listitem>
<listitem><simpara>bgr</simpara></listitem>
<listitem><simpara>vrgb</simpara></listitem>
<listitem><simpara>vbgr</simpara></listitem>
</itemizedlist>
The #ClutterShader structure contains only private data
and should be accessed using the provided API
Create a new #ClutterShader instance.
a new #ClutterShader.
Enables a shader. This function will attempt to compile and link
the shader, if it isn't already.
When @enabled is %FALSE the default state of the GL pipeline will be
used instead.
The new state of the shader.
Checks whether @shader is enabled.
%TRUE if the shader is enabled.
Compiles and links GLSL sources set for vertex and fragment shaders for
a #ClutterShader. If the compilation fails and a #GError return location is
provided the error will contain the errors from the compiler, if any.
returns TRUE if the shader was succesfully compiled.
Frees up any GL context resources held by the shader.
Checks whether @shader is is currently compiled, linked and bound
to the GL context.
%TRUE if the shader is compiled, linked and ready for use.
Sets the GLSL source code to be used by a #ClutterShader for the vertex
program.
GLSL source code.
length of source buffer (currently ignored)
Sets the GLSL source code to be used by a #ClutterShader for the fragment
program.
GLSL source code.
length of source buffer (currently ignored)
Query the current GLSL vertex source set on @shader.
ClutterShader object or %NULL. The returned string is owned by the
shader object and should never be modified or freed
the source of the vertex shader for this
Query the current GLSL fragment source set on @shader.
ClutterShader object or %NULL. The returned string is owned by the
shader object and should never be modified or freed
the source of the fragment shader for this
Sets a user configurable variable in the GLSL shader programs attached to
a #ClutterShader.
name of uniform in GLSL shader program to set.
a #ClutterShaderFloat, #ClutterShaderInt or #ClutterShaderMatrix #GValue.
Retrieves the underlying #CoglHandle for the shader program.
A #CoglHandle for the shader program, or %NULL
Retrieves the underlying #CoglHandle for the fragment shader.
A #CoglHandle for the fragment shader, or %NULL
Retrieves the underlying #CoglHandle for the vertex shader.
A #CoglHandle for the vertex shader, or %NULL
Whether the shader is compiled and linked, ready for use
in the GL context.
Whether the shader is currently used in the GL rendering pipeline.
GLSL source code for the fragment shader part of the shader program.
GLSL source code for the vertex shader part of the shader
program, if any
The #ClutterShaderClass structure contains only private data
The <structname>ClutterShaderEffect</structname> structure contains
only private data and should be accessed using the provided API
Sets the source of the GLSL shader used by @effect
This function should only be called by implementations of
the #ClutterShaderEffect class, and not by application code.
This function can only be called once; subsequent calls will
yield no result.
%TRUE if the source was set
the source of a GLSL shader
Sets a list of values as the payload for the uniform @name inside
the shader effect
%G_TYPE_FLOAT, for 1 or more floating point values;
%CLUTTER_TYPE_SHADER_INT, for a pointer to an array of integer values;
%CLUTTER_TYPE_SHADER_FLOAT, for a pointer to an array of floating point
values; and %CLUTTER_TYPE_SHADER_MATRIX, for a pointer to an array of
floating point values mapping a matrix
The number of values interepreted is defined by the @n_value
argument, and by the @gtype argument. For instance, a uniform named
"sampler0" and containing a single integer value is set using:
|[
clutter_shader_effect_set_uniform (effect, "sampler0",
G_TYPE_INT, 1,
0);
]|
While a uniform named "components" and containing a 3-elements vector
of floating point values (a "vec3") can be set using:
|[
gfloat component_r, component_g, component_b;
clutter_shader_effect_set_uniform (effect, "components",
G_TYPE_FLOAT, 3,
component_r,
component_g,
component_b);
]|
or can be set using:
|[
gfloat component_vec[3];
clutter_shader_effect_set_uniform (effect, "components",
CLUTTER_TYPE_SHADER_FLOAT, 3,
component_vec);
]|
Finally, a uniform named "map" and containing a matrix can be set using:
|[
clutter_shader_effect_set_uniform (effect, "map",
CLUTTER_TYPE_SHADER_MATRIX, 1,
cogl_matrix_get_array (&matrix));
]|
the name of the uniform to set
the type of the uniform to set
the number of values
Sets @value as the payload for the uniform @name inside the shader
effect
integer value; %G_TYPE_FLOAT, for a single floating point value;
%CLUTTER_TYPE_SHADER_INT, for an array of integer values;
%CLUTTER_TYPE_SHADER_FLOAT, for an array of floating point values;
and %CLUTTER_TYPE_SHADER_MATRIX, for a matrix of floating point
values
the name of the uniform to set
a #GValue with the value of the uniform to set
Retrieves a pointer to the shader's handle
or %COGL_INVALID_HANDLE
a pointer to the shader's handle,
Retrieves a pointer to the program's handle
or %COGL_INVALID_HANDLE
a pointer to the program's handle,
The type of shader that is used by the effect. This property
should be set by the constructor of #ClutterShaderEffect
sub-classes.
The <structname>ClutterShaderEffectClass</structname> structure contains
only private data
#ClutterShader error enumeration
The type of GLSL shader program
The #ClutterStage structure contains only private data
and should be accessed using the provided API
Creates a new, non-default stage. A non-default stage is a new
top-level actor which can be used as another container. It works
exactly like the default stage, but while clutter_stage_get_default()
will always return the same instance, you will have to keep a pointer
to any #ClutterStage returned by clutter_stage_create().
The ability to support multiple stages depends on the current
backend. Use clutter_feature_available() and
%CLUTTER_FEATURE_STAGE_MULTIPLE to check at runtime whether a
backend supports multiple stages.
not support multiple stages. Use clutter_actor_destroy() to
programmatically close the returned stage.
a new stage, or %NULL if the default backend does
Returns the main stage. The default #ClutterStage is a singleton,
so the stage will be created the first time this function is
called (typically, inside clutter_init()); all the subsequent
calls to clutter_stage_get_default() will return the same instance.
Clutter guarantess the existence of the default stage.
destroy or unref the returned actor.
the main #ClutterStage. You should never
Sets the stage color.
A #ClutterColor
Retrieves the stage color.
return location for a #ClutterColor
Sets the stage perspective.
A #ClutterPerspective
Retrieves the stage perspective.
return location for a #ClutterPerspective
Asks to place the stage window in the fullscreen or unfullscreen
states.
afterward, because other entities (e.g. the user or window manager)
could unfullscreen it again, and not all window managers honor
requests to fullscreen windows.
If you want to receive notification of the fullscreen state you
should either use the #ClutterStage::fullscreen and
#ClutterStage::unfullscreen signals, or use the notify signal
for the #ClutterStage:fullscreen-set property
%TRUE to to set the stage fullscreen
Retrieves whether the stage is full screen or not
%TRUE if the stage is full screen
Shows the cursor on the stage window
Makes the cursor invisible on the stage window
Checks the scene at the coordinates @x and @y and returns a pointer
to the #ClutterActor at those coordinates.
By using @pick_mode it is possible to control which actors will be
painted and thus available.
if any
the actor at the specified coordinates,
how the scene graph should be painted
X coordinate to check
Y coordinate to check
Makes a screenshot of the stage in RGBA 8bit data, returns a
linear buffer with @width * 4 as rowstride.
The alpha data contained in the returned buffer is driver-dependent,
and not guaranteed to hold any sensible value.
or %NULL if the read failed. Use g_free() on the returned data
to release the resources it has allocated.
a pointer to newly allocated memory with the buffer
x coordinate of the first pixel that is read from stage
y coordinate of the first pixel that is read from stage
Width dimention of pixels to be read, or -1 for the entire stage width
Height dimention of pixels to be read, or -1 for the entire stage height
This function is used to emit an event on the main stage.
You should rarely need to use this function, except for
synthetised events.
the return value from the signal emission
a #ClutterEvent
Sets if the stage is resizable by user interaction (e.g. via
window manager controls)
whether the stage should be user resizable.
Retrieves the value set with clutter_stage_set_user_resizable().
%TRUE if the stage is resizable by the user.
Sets whether the depth cueing effect on the stage should be enabled
or not.
Depth cueing is a 3D effect that makes actors farther away from the
viewing point less opaque, by fading them with the stage color.
The parameters of the GL fog used can be changed using the
clutter_stage_set_fog() function.
%TRUE for enabling the depth cueing effect
Gets whether the depth cueing effect is enabled on @stage.
%TRUE if the the depth cueing effect is enabled
Sets the fog (also known as "depth cueing") settings for the @stage.
A #ClutterStage will only use a linear fog progression, which
depends solely on the distance from the viewer. The cogl_set_fog()
function in COGL exposes more of the underlying implementation,
and allows changing the for progression function. It can be directly
used by disabling the #ClutterStage:use-fog property and connecting
a signal handler to the #ClutterActor::paint signal on the @stage,
like:
|[
clutter_stage_set_use_fog (stage, FALSE);
g_signal_connect (stage, "paint", G_CALLBACK (on_stage_paint), NULL);
]|
The paint signal handler will call cogl_set_fog() with the
desired settings:
|[
static void
on_stage_paint (ClutterActor *actor)
{
ClutterColor stage_color = { 0, };
CoglColor fog_color = { 0, };
/* set the fog color to the stage background color */
clutter_stage_get_color (CLUTTER_STAGE (actor), &stage_color);
cogl_color_set_from_4ub (&fog_color,
stage_color.red,
stage_color.green,
stage_color.blue,
stage_color.alpha);
/* enable fog */
cogl_set_fog (&fog_color,
COGL_FOG_MODE_EXPONENTIAL, /* mode */
0.5, /* density */
5.0, 30.0); /* z_near and z_far */
}
]|
unmultiplied alpha colors. By default Cogl will premultiply textures
and cogl_set_source_color will premultiply colors, so unless you
explicitly load your textures requesting an unmultiplied
internal_format and use cogl_material_set_color you can only use
fogging with fully opaque actors.
We can look to improve this in the future when we can depend on
fragment shaders.
a #ClutterFog structure
Retrieves the current depth cueing settings from the stage.
return location for a #ClutterFog structure
Sets the key focus on @actor. An actor with key focus will receive
all the key events. If @actor is %NULL, the stage will receive
focus.
the actor to set key focus to, or %NULL
Retrieves the actor that is currently under key focus.
the actor with key focus, or the stage
This function essentially makes sure the right GL context is
current for the passed stage. It is not intended to
be used by applications.
Queues a redraw for the passed stage.
<note>Applications should call clutter_actor_queue_redraw() and not
this function.</note>
<note>This function is just a wrapper for clutter_actor_queue_redraw()
and should probably go away.</note>
Checks if @stage is the default stage, or an instance created using
clutter_stage_new() but internally using the same implementation.
%TRUE if the passed stage is the default one
Ensures that the GL viewport is updated with the current
stage window size.
This function will queue a redraw of @stage.
This function should not be called by applications; it is used
when embedding a #ClutterStage into a toolkit with another
windowing system, like GTK+.
Ensures that @stage is redrawn
used when embedding a #ClutterStage into a toolkit with
another windowing system, like GTK+.
Sets whether motion events received between redraws should
be throttled or not. If motion events are throttled, those
events received by the windowing system between redraws will
be compressed so that only the last event will be propagated
to the @stage and its actors.
This function should only be used if you want to have all
the motion events delivered to your application code.
%TRUE to throttle motion events
Retrieves the value set with clutter_stage_set_throttle_motion_events()
and %FALSE otherwise
%TRUE if the motion events are being throttled,
Sets whether the @stage should honour the #ClutterActor:opacity and
the alpha channel of the #ClutterStage:color
whether the stage should honour the opacity or the alpha channel of the stage color
Retrieves the value set using clutter_stage_set_use_alpha()
alpha channel of the stage color
%TRUE if the stage should honour the opacity and the
Sets the minimum size for a stage window, if the default backend
uses #ClutterStage inside a window
This is a convenience function, and it is equivalent to setting the
#ClutterActor:min-width and #ClutterActor:min-height on @stage
If the current size of @stage is smaller than the minimum size, the
This function has no effect if @stage is fullscreen
width, in pixels
height, in pixels
Retrieves the minimum size for a stage window as set using
clutter_stage_set_minimum_size().
The returned size may not correspond to the actual minimum size and
it is specific to the #ClutterStage implementation inside the
Clutter backend
return location for the minimum width, in pixels, or %NULL
return location for the minimum height, in pixels, or %NULL
Sets whether the @stage should clear itself at the beginning
of each paint cycle or not.
Clearing the #ClutterStage can be a costly operation, especially
if the stage is always covered - for instance, in a full-screen
video player or in a game with a background texture.
<note><para>This setting is a hint; Clutter might discard this
hint depending on its internal state.</para></note>
<warning><para>If parts of the stage are visible and you disable
clearing you might end up with visual artifacts while painting the
contents of the stage.</para></warning>
%TRUE if the @stage should not clear itself on every repaint cycle
Retrieves the hint set with clutter_stage_set_no_clear_hint()
cycle, and %FALSE otherwise
%TRUE if the stage should not clear itself on every paint
The color of the main stage.
Whether the mouse pointer should be visible
The settings for the GL "fog", used only if #ClutterStage:use-fog
is set to %TRUE
The #ClutterActor that will receive key events from the underlying
windowing system.
If %NULL, the #ClutterStage will receive the events.
Whether or not the #ClutterStage should clear its contents
before each paint cycle.
See clutter_stage_set_no_clear_hint() for further information.
Whether the stage should be rendered in an offscreen buffer.
<warning><para>Not every backend supports redirecting the
stage to an offscreen buffer. This property might not work
and it might be deprecated at any later date.</para></warning>
The parameters used for the perspective projection from 3D
coordinates to 2D
The stage's title - usually displayed in stage windows title decorations.
Whether the #ClutterStage should honour the alpha component of the
#ClutterStage:color property when painting. If Clutter is run under
a compositing manager this will result in the stage being blended
with the underlying window(s)
Whether the stage should use a linear GL "fog" in creating the
depth-cueing effect, to enhance the perception of depth by fading
actors farther from the viewpoint.
Whether the stage is resizable via user interaction.
The ::delete-event signal is emitted when the user closes a
#ClutterStage window using the window controls.
Clutter by default will call clutter_main_quit() if @stage is
the default stage, and clutter_actor_destroy() for any other
stage.
It is possible to override the default behaviour by connecting
a new handler and returning %TRUE there.
<note>This signal is emitted only on Clutter backends that
embed #ClutterStage in native windows. It is not emitted for
backends that use a static frame buffer.</note>
a #ClutterEvent of type %CLUTTER_DELETE
The #ClutterStageClass structure contains only private data
The #ClutterStageManager structure is private.
Returns the default #ClutterStageManager.
object is owned by Clutter and you should not reference or unreference it.
the default stage manager instance. The returned
Returns the default #ClutterStage.
is owned by Clutter and you should never reference or unreference it
the default stage. The returned object
Lists all currently used stages.
allocated list of #ClutterStage objects. Use g_slist_free() to
deallocate it when done.
a newly
Lists all currently used stages.
to the internal list of #ClutterStage objects. The returned list
is owned by the #ClutterStageManager and should never be modified
or freed
a pointer
Sets @stage as the default stage.
a #ClutterStage
The default stage used by Clutter.
The ::stage-added signal is emitted each time a new #ClutterStage
has been added to the stage manager.
the added stage
The ::stage-removed signal is emitted each time a #ClutterStage
has been removed from the stage manager.
the removed stage
The #ClutterStageManagerClass structure contains only private data
and should be accessed using the provided API
Stage state masks
Event signalling a change in the #ClutterStage state.
The <structname>ClutterState</structname> structure contains only
private data and should be accessed using the provided API
Creates a new #ClutterState
the newly create #ClutterState instance
Change the current state of #ClutterState to @target_state_name
The state will animate during its transition, see
#clutter_state_warp_to_state for animation-free state switching.
the #ClutterTimeline that drives the state transition
the state to transition to
Change the current state of #ClutterState to @target_state_name
Change to the specified target state immediately with no animation.
the #ClutterTimeline that drives the state transition
the state to transition to
Sets one specific end key for a state_name, object, property_name
combination.
multiple calls
the #ClutterState instance, allowing chaining of
the source transition to specify transition for or NULL to specify the default fallback when a more specific source_state doesn't exist.
the name of the transition to set a key value for.
the #GObject to set a key for
the property to set a key for
the id of the alpha function to use
the value for property_name of object in state_name
relative time of the transition to be idle in the beginning of the transition
relative time of the transition to be idle in the end of the transition
Sets the duration of a transition.
If both state names are %NULL the default duration for @state is set.
If only @target_state_name is specified, the passed @duration becomes
the default duration for transitions to the target state.
If both states names are specified, the passed @duration only applies
to the specified transition.
the name of the source state, or %NULL
the name of the target state, or %NULL
the duration of the transition, in milliseconds
Queries the duration used for transitions between a source and
target state pair
The semantics for the query are the same as the semantics used for
setting the duration with clutter_state_set_duration()
the duration, in milliseconds
the name of the source state to get the duration of, or %NULL
the name of the source state to get the duration of, or %NULL
Adds multiple keys to a named state of a #ClutterState instance, specifying
the easing mode and value a given property of an object should have at a
given progress of the animation.
The mode specified is the easing mode used when going to from the previous
key to the specified key.
For instance, the code below:
|[
clutter_state_set (state, NULL, "hover",
button, "opacity", 255, CLUTTER_LINEAR,
button, "scale-x", 1.2, CLUTTER_EASE_OUT_CUBIC,
button, "scale-y", 1.2, CLUTTER_EASE_OUT_CUBIC,
NULL);
]|
will create a transition from any state (a @source_state_name of NULL is
treated as a wildcard) and a state named "hover"; the
<emphasis>button</emphasis> object will have the #ClutterActor:opacity
property animated to a value of 255 using %CLUTTER_LINEAR as the animation
mode, and the #ClutterActor:scale-x and #ClutterActor:scale-y properties
animated to a value of 1.2 using %CLUTTER_EASE_OUT_CUBIC as the animation
mode. To change the state (and start the transition) you can use the
clutter_state_change() function:
|[
clutter_state_change (state, "hover", TRUE);
]|
If a given object, state_name, property tuple already exist in the
#ClutterState instance, then the mode and value will be replaced with
the new specified values.
If a property name is prefixed with "delayed::" two additional
to pause before transitioning and a similar value to pause after
transitioning, e.g.:
|[
clutter_state_set (state, "hover", "toggled",
button, "delayed::scale-x", 1.0, 0.2, 0.2,
button, "delayed::scale-y", 1.0, 0.2, 0.2,
NULL);
]|
will pause for 20% of the duration of the transition before animating,
and 20% of the duration after animating.
the name of the source state keys are being added for
the name of the target state keys are being added for
a #GObject
a property of @first_object to specify a key for
the id of the alpha function to use
Gets a list of all the state names managed by this #ClutterState.
#GList of state names. The contents of the returned #GList are owned
by the #ClutterState and should not be modified or freed. Use
g_list_free() to free the resources allocated by the returned list when
done using it
a newly allocated
Returns a list of pointers to opaque structures with accessor functions
that describe the keys added to an animator.
newly allocated #GList of #ClutterStateKey<!-- -->s. The contents of
the returned list are owned by the #ClutterState and should not be
modified or freed. Use g_list_free() to free the resources allocated
by the returned list when done using it
a
the source transition name to query, or %NULL for all source states
the target transition name to query, or %NULL for all target states
the specific object instance to list keys for, or %NULL for all managed objects
the property name to search for, or %NULL for all properties.
Removes all keys matching the search criteria passed in arguments.
the source state name to query, or %NULL for all source states
the target state name to query, or %NULL for all target states
the specific object instance to list keys for, or %NULL for all managed objects
the property name to search for, or %NULL for all properties.
Gets the timeline driving the #ClutterState
the state change animations. The returned timeline is owned
by the #ClutterState and it should not be unreferenced directly
the #ClutterTimeline that drives
Specifies a #ClutterAnimator to be used when transitioning between
the two named states.
The @animator allows specifying a transition between the state that is
more elaborate than the basic transitions other allowed by the simple
tweening of properties defined in the #ClutterState keys.
If @animator is %NULL it will unset an existing animator.
#ClutterState will take a reference on the passed @animator, if any
the name of a source state
the name of a target state
a #ClutterAnimator instance, or %NULL to unset an existing #ClutterAnimator
Retrieves the #ClutterAnimator that is being used for transitioning
between the two states, if any has been set
a #ClutterAnimator instance, or %NULL
the name of a source state
the name of a target state
Queries the currently set target state.
During a transition this function will return the target of the transition.
This function is useful when called from handlers of the
#ClutterState::completed signal.
is owned by the #ClutterState and should not be modified or freed
a string containing the target state. The returned string
Default duration used if an duration has not been specified for a specific
source/target state pair. The values is in milliseconds.
The currently set target state, setting it causes the
state machine to transition to the new state, use
clutter_state_change() with a final FALSE argument to
change state without a transition.
The ::completed signal is emitted when a #ClutterState reaches
the target state specified by clutter_state_change()
The <structname>ClutterStateClass</structname> structure contains
only private data
<structname>ClutterStateKey</structname> is an opaque structure whose
members cannot be accessed directly
Retrieves the pause before transitioning starts as a fraction of
the total transition time.
the pre delay used before starting the transition.
Retrieves the duration of the pause after transitioning is complete
as a fraction of the total transition time.
the post delay, used after doing the transition.
Retrieves the easing mode used for @state_key.
the mode of a #ClutterStateKey
Retrieves a copy of the value for a #ClutterStateKey.
The #GValue needs to be already initialized for the value type
of the property or to a type that allow transformation from the value
type of the key.
Use g_value_unset() when done.
and %FALSE otherwise
%TRUE if the value was successfully retrieved,
a #GValue initialized with the correct type for the @state_key
Retrieves the #GType of the property a key applies to
You can use this type to initialize the #GValue to pass to
clutter_state_key_get_value()
the #GType of the property
Retrieves the object instance this #ClutterStateKey applies to.
the object this state key applies to.
Retrieves the name of the property this #ClutterStateKey applies to
by the #ClutterStateKey and should never be modified or freed
the name of the property. The returned string is owned
Retrieves the name of the source state of the @state_key
if this is the generic state key for the given property when
transitioning to the target state. The returned string is owned
by the #ClutterStateKey and should never be modified or freed
the name of the source state for this key, or %NULL
Get the name of the source state this #ClutterStateKey contains,
or NULL if this is the generic state key for the given property
when transitioning to the target state.
the key is generic
the name of the source state for this key, or NULL if
The alignment policies available on each axis of the #ClutterTableLayout
The #ClutterTableLayout structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterTableLayout layout manager
the newly created #ClutterTableLayout
Packs @actor inside the #ClutterContainer associated to @layout
at the given row and column.
a #ClutterActor
the row the @actor should be put, or -1 to append
the column the @actor should be put, or -1 to append
Sets the spacing between columns of @layout
the spacing between columns of the layout, in pixels
Sets the spacing between rows of @layout
the spacing between rows of the layout, in pixels
Retrieves the spacing set using clutter_table_layout_set_column_spacing()
the spacing between columns of the #ClutterTableLayout
Retrieves the spacing set using clutter_table_layout_set_row_spacing()
the spacing between rows of the #ClutterTableLayout
Sets the row and column span for @actor
inside @layout
a #ClutterActor child of @layout
Column span for @actor
Row span for @actor
Retrieves the row and column span for @actor as set using
clutter_table_layout_pack() or clutter_table_layout_set_span()
a #ClutterActor child of @layout
return location for the col span
return location for the row span
Sets the horizontal and vertical alignment policies for @actor
inside @layout
a #ClutterActor child of @layout
Horizontal alignment policy for @actor
Vertical alignment policy for @actor
Retrieves the horizontal and vertical alignment policies for @actor
as set using clutter_table_layout_pack() or
clutter_table_layout_set_alignment().
a #ClutterActor child of @layout
return location for the horizontal alignment policy
return location for the vertical alignment policy
Sets the horizontal and vertical fill policies for @actor
inside @layout
a #ClutterActor child of @layout
whether @actor should fill horizontally the allocated space
whether @actor should fill vertically the allocated space
Retrieves the horizontal and vertical fill policies for @actor
as set using clutter_table_layout_pack() or clutter_table_layout_set_fill()
a #ClutterActor child of @layout
return location for the horizontal fill policy
return location for the vertical fill policy
Sets the horizontal and vertical expand policies for @actor
inside @layout
a #ClutterActor child of @layout
whether @actor should allocate extra space horizontally
whether @actor should allocate extra space vertically
Retrieves the horizontal and vertical expand policies for @actor
as set using clutter_table_layout_pack() or clutter_table_layout_set_expand()
a #ClutterActor child of @layout
return location for the horizontal expand policy
return location for the vertical expand policy
Retrieve the current number rows in the @layout
the number of rows
Retrieve the current number of columns in @layout
the number of columns
Sets whether @layout should animate changes in the layout properties
The duration of the animations is controlled by
clutter_table_layout_set_easing_duration(); the easing mode to be used
by the animations is controlled by clutter_table_layout_set_easing_mode()
%TRUE if the @layout should use animations
Retrieves whether @layout should animate changes in the layout properties
Since clutter_table_layout_set_use_animations()
%TRUE if the animations should be used, %FALSE otherwise
Sets the easing mode to be used by @layout when animating changes in layout
properties
Use clutter_table_layout_set_use_animations() to enable and disable the
animations
an easing mode, either from #ClutterAnimationMode or a logical id from clutter_alpha_register_func()
Retrieves the easing mode set using clutter_table_layout_set_easing_mode()
an easing mode
Sets the duration of the animations used by @layout when animating changes
in the layout properties
Use clutter_table_layout_set_use_animations() to enable and disable the
animations
the duration of the animations, in milliseconds
Retrieves the duration set using clutter_table_layout_set_easing_duration()
the duration of the animations, in milliseconds
The spacing between columns of the #ClutterTableLayout, in pixels
The duration of the animations, in case #ClutterTableLayout:use-animations
is set to %TRUE
The duration is expressed in milliseconds
The easing mode for the animations, in case
#ClutterTableLayout:use-animations is set to %TRUE
either be a value from the #ClutterAnimationMode enumeration, like
%CLUTTER_EASE_OUT_CUBIC, or a logical id as returned by
clutter_alpha_register_func()
The default value is %CLUTTER_EASE_OUT_CUBIC
The spacing between rows of the #ClutterTableLayout, in pixels
Whether the #ClutterTableLayout should animate changes in the
layout properties
The #ClutterTableLayoutClass structure contains only private
data and should be accessed using the provided API
The #ClutterText struct contains only private data.
Creates a new #ClutterText actor. This actor can be used to
display and edit text.
the newly created #ClutterText actor
Creates a new #ClutterText actor, using @font_name as the font
description; @text will be used to set the contents of the actor;
and @color will be used as the color to render @text.
This function is equivalent to calling clutter_text_new(),
clutter_text_set_font_name(), clutter_text_set_text() and
clutter_text_set_color().
the newly created #ClutterText actor
a string with a font description
the contents of the actor
the color to be used to render @text
Creates a new #ClutterText actor, using @font_name as the font
description; @text will be used to set the contents of the actor.
This function is equivalent to calling clutter_text_new(),
clutter_text_set_font_name(), and clutter_text_set_text().
the newly created #ClutterText actor
a string with a font description
the contents of the actor
Retrieves a pointer to the current contents of a #ClutterText
actor.
If you need a copy of the contents for manipulating, either
use g_strdup() on the returned string, or use:
|[
copy = clutter_text_get_chars (text, 0, -1);
]|
Which will return a newly allocated string.
is owned by the #ClutterText actor and should never be
modified or freed
the contents of the actor. The returned string
Sets the contents of a #ClutterText actor.
If the #ClutterText:use-markup property was set to %TRUE it
will be reset to %FALSE as a side effect. If you want to
maintain the #ClutterText:use-markup you should use the
clutter_text_set_markup() function instead
the text to set. Passing %NULL is the same as passing "" (the empty string)
Sets @markup as the contents of a #ClutterText.
This is a convenience function for setting a string containing
Pango markup, and it is logically equivalent to:
|[
clutter_text_set_text (CLUTTER_TEXT (actor), markup);
clutter_text_set_use_markup (CLUTTER_TEXT (actor), TRUE);
]|
a string containing Pango markup. Passing %NULL is the same as passing "" (the empty string)
Sets the color of the contents of a #ClutterText actor.
The overall opacity of the #ClutterText actor will be the
result of the alpha value of @color and the composited
opacity of the actor itself on the scenegraph, as returned
by clutter_actor_get_paint_opacity().
a #ClutterColor
Retrieves the text color as set by clutter_text_set_color().
return location for a #ClutterColor
Sets the font used by a #ClutterText. The @font_name string
must either be %NULL, which means that the font name from the
default #ClutterBackend will be used; or be something that can
be parsed by the pango_font_description_from_string() function,
like:
|[
clutter_text_set_font_name (text, "Sans 10pt");
clutter_text_set_font_name (text, "Serif 16px");
clutter_text_set_font_name (text, "Helvetica 10");
]|
a font name, or %NULL to set the default font name
Retrieves the font name as set by clutter_text_set_font_name().
string is owned by the #ClutterText actor and should not be
modified or freed
a string containing the font name. The returned
Sets @font_desc as the font description for a #ClutterText
The #PangoFontDescription is copied by the #ClutterText actor
so you can safely call pango_font_description_free() on it after
calling this function.
a #PangoFontDescription
Retrieves the #PangoFontDescription used by @self
by the #ClutterText actor and it should not be modified or freed
a #PangoFontDescription. The returned value is owned
text if there is not enough space to render the entire contents
of a #ClutterText actor
a #PangoEllipsizeMode
Returns the ellipsizing position of a #ClutterText actor, as
set by clutter_text_set_ellipsize().
#PangoEllipsizeMode
Sets whether the contents of a #ClutterText actor should wrap,
if they don't fit the size assigned to the actor.
whether the contents should wrap
Retrieves the value set using clutter_text_set_line_wrap().
its contents
%TRUE if the #ClutterText actor should wrap
If line wrapping is enabled (see clutter_text_set_line_wrap()) this
function controls how the line wrapping is performed. The default is
%PANGO_WRAP_WORD which means wrap on word boundaries.
the line wrapping mode
Retrieves the line wrap mode used by the #ClutterText actor.
See clutter_text_set_line_wrap_mode ().
the wrap mode used by the #ClutterText
Retrieves the current #PangoLayout used by a #ClutterText actor.
the #ClutterText actor and should not be modified or freed
a #PangoLayout. The returned object is owned by
Sets the attributes list that are going to be applied to the
#ClutterText contents.
The #ClutterText actor will take a reference on the #PangoAttrList
passed to this function.
a #PangoAttrList or %NULL to unset the attributes
Gets the attribute list that was set on the #ClutterText actor
clutter_text_set_attributes(), if any.
returned value is owned by the #ClutterText and should not be unreferenced.
the attribute list, or %NULL if none was set. The
Sets whether the contents of the #ClutterText actor contains markup
in <link linkend="PangoMarkupFormat">Pango's text markup language</link>.
Setting #ClutterText:use-markup on an editable #ClutterText will
not have any effect except hiding the markup.
See also #ClutterText:use-markup.
%TRUE if the text should be parsed for markup.
Retrieves whether the contents of the #ClutterText actor should be
parsed for the Pango text markup.
%TRUE if the contents will be parsed for markup
Sets the way that the lines of a wrapped label are aligned with
respect to each other. This does not affect the overall alignment
of the label within its allocated or specified width.
To align a #ClutterText actor you should add it to a container
that supports alignment, or use the anchor point.
A #PangoAlignment
Retrieves the alignment of a #ClutterText, as set by
clutter_text_set_line_alignment().
a #PangoAlignment
Sets whether the text of the #ClutterText actor should be justified
on both margins. This setting is ignored if Clutter is compiled
against Pango < 1.18.
whether the text should be justified
Retrieves whether the #ClutterText actor should justify its contents
on both margins.
%TRUE if the text should be justified
Inserts @wc at the current cursor position of a
#ClutterText actor.
a Unicode character
Deletes @n_chars inside a #ClutterText actor, starting from the
current cursor position.
the number of characters to delete
Inserts @text into a #ClutterActor at the given position.
If @position is a negative number, the text will be appended
at the end of the current contents of the #ClutterText.
The position is expressed in characters, not in bytes.
the text to be inserted
the position of the insertion, or -1
Deletes the text inside a #ClutterText actor between @start_pos
and @end_pos.
The starting and ending positions are expressed in characters,
not in bytes.
starting position
ending position
Retrieves the contents of the #ClutterText actor between
The positions are specified in characters, not in bytes.
the text actor between the specified positions. Use g_free()
to free the resources when done
a newly allocated string with the contents of
start of text, in characters
end of text, in characters
Sets whether the #ClutterText actor should be editable.
An editable #ClutterText with key focus set using
clutter_actor_grab_key_focus() or clutter_stage_take_key_focus()
will receive key events and will update its contents accordingly.
whether the #ClutterText should be editable
Retrieves whether a #ClutterText is editable or not.
%TRUE if the actor is editable
Sets whether a #ClutterText actor should be activatable.
An activatable #ClutterText actor will emit the #ClutterText::activate
signal whenever the 'Enter' (or 'Return') key is pressed; if it is not
activatable, a new line will be appended to the current content.
An activatable #ClutterText must also be set as editable using
clutter_text_set_editable().
whether the #ClutterText actor should be activatable
Retrieves whether a #ClutterText is activatable or not.
%TRUE if the actor is activatable
Retrieves the cursor position.
the cursor position, in characters
Sets the cursor of a #ClutterText actor at @position.
The position is expressed in characters, not in bytes.
the new cursor position, in characters
Sets whether the cursor of a #ClutterText actor should be
visible or not.
The color of the cursor will be the same as the text color
unless clutter_text_set_cursor_color() has been called.
The size of the cursor can be set using clutter_text_set_cursor_size().
The position of the cursor can be changed programmatically using
clutter_text_set_cursor_position().
whether the cursor should be visible
Retrieves whether the cursor of a #ClutterText actor is visible.
%TRUE if the cursor is visible
Sets the color of the cursor of a #ClutterText actor.
If @color is %NULL, the cursor color will be the same as the
text color.
the color of the cursor, or %NULL to unset it
Retrieves the color of the cursor of a #ClutterText actor.
return location for a #ClutterColor
Sets the size of the cursor of a #ClutterText. The cursor
will only be visible if the #ClutterText:cursor-visible property
is set to %TRUE.
the size of the cursor, in pixels, or -1 to use the default value
Retrieves the size of the cursor of a #ClutterText actor.
the size of the cursor, in pixels
Sets whether a #ClutterText actor should be selectable.
A selectable #ClutterText will allow selecting its contents using
the pointer or the keyboard.
whether the #ClutterText actor should be selectable
Retrieves whether a #ClutterText is selectable or not.
%TRUE if the actor is selectable
Sets the other end of the selection, starting from the current
cursor position.
If @selection_bound is -1, the selection unset.
the position of the end of the selection, in characters
Retrieves the other end of the selection of a #ClutterText actor,
in characters from the current cursor position.
the position of the other end of the selection
Selects the region of text between @start_pos and @end_pos.
This function changes the position of the cursor to match
start of the selection, in characters
end of the selection, in characters
Retrieves the currently selected text.
selected text, or %NULL. Use g_free() to free the returned
string.
a newly allocated string containing the currently
Sets the color of the selection of a #ClutterText actor.
If @color is %NULL, the selection color will be the same as the
cursor color, or if no cursor color is set either then it will be
the same as the text color.
the color of the selection, or %NULL to unset it
Retrieves the color of the selection of a #ClutterText actor.
return location for a #ClutterColor
Deletes the currently selected text
This function is only useful in subclasses of #ClutterText
is empty, and %FALSE otherwise
%TRUE if text was deleted or if the text actor
Sets the character to use in place of the actual text in a
password text actor.
If @wc is 0 the text will be displayed as it is entered in the
#ClutterText actor.
a Unicode character, or 0 to unset the password character
Retrieves the character to use in place of the actual text
as set by clutter_text_set_password_char().
character is not set
a Unicode character or 0 if the password
Sets the maximum allowed length of the contents of the actor. If the
current contents are longer than the given length, then they will be
truncated to fit.
the maximum number of characters allowed in the text actor; 0 to disable or -1 to set the length of the current string
Gets the maximum length of text that can be set into a text actor.
See clutter_text_set_max_length().
the maximum number of characters.
Sets whether a #ClutterText actor should be in single line mode
or not. Only editable #ClutterText<!-- -->s can be in single line
mode.
A text actor in single line mode will not wrap text and will clip
the the visible area to the predefined size. The contents of the
text actor will scroll to display the end of the text if its length
is bigger than the allocated width.
When setting the single line mode the #ClutterText:activatable
property is also set as a side effect. Instead of entering a new
line character, the text actor will emit the #ClutterText::activate
signal.
whether to enable single line mode
Retrieves whether the #ClutterText actor is in single line mode.
%TRUE if the #ClutterText actor is in single line mode
Emits the #ClutterText::activate signal, if @self has been set
as activatable using clutter_text_set_activatable().
This function can be used to emit the ::activate signal inside
a #ClutterActor::captured-event or #ClutterActor::key-press-event
signal handlers before the default signal handler for the
#ClutterText is invoked.
and %FALSE otherwise
%TRUE if the ::activate signal has been emitted,
Retrieves the coordinates of the given @position.
%TRUE if the conversion was successful
position in characters
return location for the X coordinate, or %NULL
return location for the Y coordinate, or %NULL
return location for the line height, or %NULL
Sets, or unsets, the pre-edit string. This function is useful
for input methods to display a string (with eventual specific
Pango attributes) before it is entered inside the #ClutterText
buffer.
The preedit string and attributes are ignored if the #ClutterText
actor is not editable.
This function should not be used by applications
the pre-edit string, or %NULL to unset it
the pre-edit string attributes
the cursor position for the pre-edit string
Toggles whether return invokes the activate signal or not.
A list of #PangoStyleAttribute<!-- -->s to be applied to the
contents of the #ClutterText actor.
The color used to render the text.
The color of the cursor.
Will be set to %TRUE if #ClutterText:cursor-color has been set.
The size of the cursor, in pixels. If set to -1 the size used will
be the default cursor size of 2 pixels.
Whether the input cursor is visible or not, it will only be visible
if both #ClutterText:cursor-visible and #ClutterText:editable are
set to %TRUE.
Whether key events delivered to the actor causes editing.
The preferred place to ellipsize the contents of the #ClutterText actor
The #PangoFontDescription that should be used by the #ClutterText
If you have a string describing the font then you should look at
#ClutterText:font-name instead
The font to be used by the #ClutterText, as a string
that can be parsed by pango_font_description_from_string().
If set to %NULL, the default system font will be used instead.
Whether the contents of the #ClutterText should be justified
on both margins.
The preferred alignment for the text. This property controls
the alignment of multi-line paragraphs.
Whether to wrap the lines of #ClutterText:text if the contents
exceed the available allocation. The wrapping strategy is
controlled by the #ClutterText:line-wrap-mode property.
If #ClutterText:line-wrap is set to %TRUE, this property will
control how the text is wrapped.
The maximum length of the contents of the #ClutterText actor.
If non-zero, the character that should be used in place of
the actual text in a password text actor.
The current input cursor position. -1 is taken to be the end of the text
Whether it is possible to select text, either using the pointer
or the keyboard.
The current input cursor position. -1 is taken to be the end of the text
The color of the selection.
Will be set to %TRUE if #ClutterText:selection-color has been set.
Whether the #ClutterText actor should be in single line mode
or not. A single line #ClutterText actor will only contain a
single line of text, scrolling it in case its length is bigger
than the allocated size.
Setting this property will also set the #ClutterText:activatable
property as a side-effect.
The #ClutterText:single-line-mode property is used only if the
#ClutterText:editable property is set to %TRUE.
The text to render inside the actor.
Whether the text includes Pango markup.
For more informations about the Pango markup format, see
pango_layout_set_markup() in the Pango documentation.
<note>It is not possible to round-trip this property between
%TRUE and %FALSE. Once a string with markup has been set on
a #ClutterText actor with :use-markup set to %TRUE, the markup
is stripped from the string.</note>
The ::cursor-event signal is emitted whenever the cursor position
changes inside a #ClutterText actor. Inside @geometry it is stored
the current position and size of the cursor, relative to the actor
itself.
the coordinates of the cursor
This signal is emitted when text is deleted from the actor by
the user. It is emitted before @self text changes.
the starting position
the end position
This signal is emitted when text is inserted into the actor by
the user. It is emitted before @self text changes.
the new text to insert
the length of the new text, in bytes, or -1 if new_text is nul-terminated
the position, in characters, at which to insert the new text. this is an in-out parameter. After the signal emission is finished, it should point after the newly inserted text.
The ::text-changed signal is emitted after @actor's text changes
The #ClutterTextClass struct contains only private data.
The text direction to be used by #ClutterActor<!-- -->s
The #ClutterTexture structure contains only private data
and should be accessed using the provided API
Creates a new empty #ClutterTexture object.
A newly created #ClutterTexture object.
Creates a new ClutterTexture actor to display the image contained a
file. If the image failed to load then NULL is returned and @error
is set.
error.
A newly created #ClutterTexture object or NULL on
The name of an image file to load.
Creates a new #ClutterTexture object with its source a prexisting
actor (and associated children). The textures content will contain
'live' redirected output of the actors scene.
Note this function is intented as a utility call for uniformly applying
shaders to groups and other potential visual effects. It requires that
the %CLUTTER_FEATURE_OFFSCREEN feature is supported by the current backend
and the target system.
Some tips on usage:
<itemizedlist>
<listitem>
<para>The source actor must be made visible (i.e by calling
#clutter_actor_show).</para>
</listitem>
<listitem>
<para>The source actor must have a parent in order for it to be
allocated a size from the layouting mechanism. If the source
actor does not have a parent when this function is called then
the ClutterTexture will adopt it and allocate it at its
preferred size. Using this you can clone an actor that is
otherwise not displayed. Because of this feature if you do
intend to display the source actor then you must make sure that
the actor is parented before calling
clutter_texture_new_from_actor() or that you unparent it before
adding it to a container.</para>
</listitem>
<listitem>
<para>When getting the image for the clone texture, Clutter
will attempt to render the source actor exactly as it would
appear if it was rendered on screen. The source actor's parent
transformations are taken into account. Therefore if your
source actor is rotated along the X or Y axes so that it has
some depth, the texture will appear differently depending on
the on-screen location of the source actor. While painting the
source actor, Clutter will set up a temporary asymmetric
perspective matrix as the projection matrix so that the source
actor will be projected as if a small section of the screen was
being viewed. Before version 0.8.2, an orthogonal identity
projection was used which meant that the source actor would be
clipped if any part of it was not on the zero Z-plane.</para>
</listitem>
<listitem>
<para>Avoid reparenting the source with the created texture.</para>
</listitem>
<listitem>
<para>A group can be padded with a transparent rectangle as to
provide a border to contents for shader output (blurring text
for example).</para>
</listitem>
<listitem>
<para>The texture will automatically resize to contain a further
transformed source. However, this involves overhead and can be
avoided by placing the source actor in a bounding group
sized large enough to contain any child tranformations.</para>
</listitem>
<listitem>
<para>Uploading pixel data to the texture (e.g by using
clutter_actor_set_from_file()) will destroy the offscreen texture data
and end redirection.</para>
</listitem>
<listitem>
<para>cogl_texture_get_data() with the handle returned by
clutter_texture_get_cogl_texture() can be used to read the
offscreen texture pixels into a pixbuf.</para>
</listitem>
</itemizedlist>
A newly created #ClutterTexture object, or %NULL on failure.
A source #ClutterActor
Sets the #ClutterTexture image data from an image file. In case of
failure, %FALSE is returned and @error is set.
If #ClutterTexture:load-async is set to %TRUE, this function
will return as soon as possible, and the actual image loading
from disk will be performed asynchronously. #ClutterTexture::size-change
will be emitten when the size of the texture is available and
#ClutterTexture::load-finished will be emitted when the image has been
loaded or if an error occurred.
%TRUE if the image was successfully loaded and set
The filename of the image in GLib file name encoding
Sets #ClutterTexture image data.
%TRUE on success, %FALSE on failure.
Image data in RGBA type colorspace.
Set to TRUE if image data has an alpha channel.
Width in pixels of image data.
Height in pixels of image data
Distance in bytes between row starts.
bytes per pixel (Currently only 3 and 4 supported, depending on @has_alpha)
#ClutterTextureFlags
Sets a #ClutterTexture from YUV image data. If an error occurred,
%FALSE is returned and @error is set.
%TRUE if the texture was successfully updated
Image data in YUV type colorspace.
Width in pixels of image data.
Height in pixels of image data
#ClutterTextureFlags
Updates a sub-region of the pixel data in a #ClutterTexture.
%TRUE on success, %FALSE on failure.
Image data in RGB type colorspace.
Set to TRUE if image data has an alpha channel.
X coordinate of upper left corner of region to update.
Y coordinate of upper left corner of region to update.
Width in pixels of region to update.
Height in pixels of region to update.
Distance in bytes between row starts on source buffer.
bytes per pixel (Currently only 3 and 4 supported, depending on @has_alpha)
#ClutterTextureFlags
Gets the size in pixels of the untransformed underlying image
return location for the width, or %NULL
return location for the height, or %NULL
Sets the filter quality when scaling a texture. The quality is an
enumeration currently the following values are supported:
%CLUTTER_TEXTURE_QUALITY_LOW which is fast but only uses nearest neighbour
interpolation. %CLUTTER_TEXTURE_QUALITY_MEDIUM which is computationally a
bit more expensive (bilinear interpolation), and
%CLUTTER_TEXTURE_QUALITY_HIGH which uses extra texture memory resources to
improve scaled down rendering as well (by using mipmaps). The default value
is %CLUTTER_TEXTURE_QUALITY_MEDIUM.
new filter quality value
Returns a handle to the underlying COGL material used for drawing
the actor. No extra reference is taken so if you need to keep the
handle then you should call cogl_handle_ref() on it.
COGL material handle
Replaces the underlying Cogl material drawn by this actor with
handle is no longer needed it should be deref'd with
cogl_handle_unref. Texture data is attached to the material so
calling this function also replaces the Cogl
texture. #ClutterTexture requires that the material have a texture
layer so you should set one on the material before calling this
function.
A CoglHandle for a material
Sets whether @texture should have the same preferred size as the
underlying image data.
%TRUE if the texture should have the same size of the underlying image data
Retrieves the value set with clutter_texture_set_sync_size()
preferred size of the underlying image data
%TRUE if the #ClutterTexture should have the same
Sets whether the @texture should repeat horizontally or
vertically when the actor size is bigger than the image size
%TRUE if the texture should repeat horizontally
%TRUE if the texture should repeat vertically
Retrieves the horizontal and vertical repeat values set
using clutter_texture_set_repeat()
return location for the horizontal repeat
return location for the vertical repeat
Retrieves the pixel format used by @texture. This is
equivalent to:
|[
handle = clutter_texture_get_pixel_format (texture);
if (handle != COGL_INVALID_HANDLE)
format = cogl_texture_get_format (handle);
]|
a #CoglPixelFormat value
Sets whether @texture should have a preferred size maintaining
the aspect ratio of the underlying image
%TRUE to maintain aspect ratio
Retrieves the value set using clutter_texture_set_keep_aspect_ratio()
aspect ratio of the underlying image
%TRUE if the #ClutterTexture should maintain the
Sets whether @texture should use a worker thread to load the data
from disk asynchronously. Setting @load_async to %TRUE will make
clutter_texture_set_from_file() return immediately.
See the #ClutterTexture:load-async property documentation, and
clutter_texture_set_load_data_async().
%TRUE if the texture should asynchronously load data from a filename
Retrieves the value set using clutter_texture_set_load_async()
disk asynchronously
%TRUE if the #ClutterTexture should load the data from
Sets whether @texture should use a worker thread to load the data
from disk asynchronously. Setting @load_async to %TRUE will make
clutter_texture_set_from_file() block until the #ClutterTexture has
determined the width and height of the image data.
See the #ClutterTexture:load-async property documentation, and
clutter_texture_set_load_async().
%TRUE if the texture should asynchronously load data from a filename
Retrieves the value set by clutter_texture_set_load_data_async()
data from a file asynchronously
%TRUE if the #ClutterTexture should load the image
Sets whether @texture should have it's shape defined by the alpha
channel when picking.
Be aware that this is a bit more costly than the default picking
due to the texture lookup, extra test against the alpha value and
the fact that it will also interrupt the batching of geometry done
internally.
Also there is currently no control over the threshold used to
determine what value of alpha is considered pickable, and so only
fully opaque parts of the texture will react to picking.
%TRUE if the alpha channel should affect the picking shape
Retrieves the value set by clutter_texture_set_load_data_async()
using the alpha channel when picking.
%TRUE if the #ClutterTexture should define its shape
The path of the file containing the image data to be displayed by
the texture.
This property is unset when using the clutter_texture_set_from_*_data()
family of functions.
Tries to load a texture from a filename by using a local thread to perform
the read operations. The initially created texture has dimensions 0x0 when
the true size becomes available the #ClutterTexture::size-change signal is
emitted and when the image has completed loading the
#ClutterTexture::load-finished signal is emitted.
Threading is only enabled if g_thread_init() has been called prior to
clutter_init(), otherwise #ClutterTexture will use the main loop to load
the image.
The upload of the texture data on the GL pipeline is not asynchronous, as
it must be performed from within the same thread that called
clutter_main().
Like #ClutterTexture:load-async but loads the width and height
synchronously causing some blocking.
The ::load-finished signal is emitted when a texture load has
completed. If there was an error during loading, @error will
be set, otherwise it will be %NULL
A set error, or %NULL
The ::pixbuf-change signal is emitted each time the pixbuf
used by @texture changes.
The ::size-change signal is emitted each time the size of the
pixbuf used by @texture changes. The new size is given as
argument to the callback.
the width of the new texture
the height of the new texture
The #ClutterTextureClass structure contains only private data
Error enumeration for #ClutterTexture
Flags for clutter_texture_set_from_rgb_data() and
clutter_texture_set_from_yuv_data().
Enumaration controlling the texture quality.
The #ClutterTimeline structure contains only private data
and should be accessed using the provided API
Creates a new #ClutterTimeline with a duration of @msecs.
g_object_unref() when done using it
the newly created #ClutterTimeline instance. Use
Duration of the timeline in milliseconds
Create a new #ClutterTimeline instance which has property values
matching that of supplied timeline. The cloned timeline will not
be started and will not be positioned to the current position of
a new #ClutterTimeline, cloned from @timeline
Retrieves the duration of a #ClutterTimeline in milliseconds.
See clutter_timeline_set_duration().
the duration of the timeline, in milliseconds.
Sets the duration of the timeline, in milliseconds. The speed
of the timeline depends on the ClutterTimeline:fps setting.
duration of the timeline in milliseconds
Retrieves the direction of the timeline set with
clutter_timeline_set_direction().
the direction of the timeline
Sets the direction of @timeline, either %CLUTTER_TIMELINE_FORWARD or
%CLUTTER_TIMELINE_BACKWARD.
the direction of the timeline
Starts the #ClutterTimeline playing.
Pauses the #ClutterTimeline on current frame
Stops the #ClutterTimeline and moves to frame 0
Sets whether @timeline should loop.
%TRUE for enable looping
Gets whether @timeline is looping
%TRUE if the timeline is looping
Rewinds #ClutterTimeline to the first frame if its direction is
%CLUTTER_TIMELINE_FORWARD and the last frame if it is
%CLUTTER_TIMELINE_BACKWARD.
Advance timeline by the requested time in milliseconds
Amount of time to skip
Advance timeline to the requested point. The point is given as a
time in milliseconds since the timeline started.
<note><para>The @timeline will not emit the #ClutterTimeline::new-frame
signal for the given time. The first ::new-frame signal after the call to
clutter_timeline_advance() will be emit the skipped markers.
</para></note>
Time to advance to
Request the current time position of the timeline.
current elapsed time in milliseconds.
The position of the timeline in a [0, 1] interval.
the position of the timeline.
Queries state of a #ClutterTimeline.
%TRUE if timeline is currently playing
Sets the delay, in milliseconds, before @timeline should start.
delay in milliseconds
Retrieves the delay set using clutter_timeline_set_delay().
the delay in milliseconds.
Retrieves the amount of time elapsed since the last
ClutterTimeline::new-frame signal.
This function is only useful inside handlers for the ::new-frame
signal, and its behaviour is undefined if the timeline is not
playing.
last frame
the amount of time in milliseconds elapsed since the
Adds a named marker that will be hit when the timeline has been
running for @msecs milliseconds. Markers are unique string
identifiers for a given time. Once @timeline reaches
attached to that time.
A marker can be removed with clutter_timeline_remove_marker(). The
timeline can be advanced to a marker using
clutter_timeline_advance_to_marker().
the unique name for this marker
position of the marker in milliseconds
Removes @marker_name, if found, from @timeline.
the name of the marker to remove
Retrieves the list of markers at time @msecs. If @frame_num is a
negative integer, all the markers attached to @timeline will be
returned.
allocated, %NULL terminated string array containing the names of
the markers. Use g_strfreev() when done.
a newly
the time to check, or -1
the number of markers returned
Checks whether @timeline has a marker set with the given name.
%TRUE if the marker was found
the name of the marker
Advances @timeline to the time of the given @marker_name.
<note><para>Like clutter_timeline_advance(), this function will not
emit the #ClutterTimeline::new-frame for the time where @marker_name
is set, nor it will emit #ClutterTimeline::marker-reached for
the name of the marker
A delay, in milliseconds, that should be observed by the
timeline before actually starting.
The direction of the timeline, either %CLUTTER_TIMELINE_FORWARD or
%CLUTTER_TIMELINE_BACKWARD.
Duration of the timeline in milliseconds, depending on the
ClutterTimeline:fps value.
Whether the timeline should automatically rewind and restart.
The ::completed signal is emitted when the timeline reaches the
number of frames specified by the ClutterTimeline:num-frames property.
The ::marker-reached signal is emitted each time a timeline
reaches a marker set with
clutter_timeline_add_marker_at_time(). This signal is detailed
with the name of the marker as well, so it is possible to connect
a callback to the ::marker-reached signal for a specific marker
with:
<informalexample><programlisting>
clutter_timeline_add_marker_at_time (timeline, "foo", 500);
clutter_timeline_add_marker_at_time (timeline, "bar", 750);
g_signal_connect (timeline, "marker-reached",
G_CALLBACK (each_marker_reached), NULL);
g_signal_connect (timeline, "marker-reached::foo",
G_CALLBACK (foo_marker_reached), NULL);
g_signal_connect (timeline, "marker-reached::bar",
G_CALLBACK (bar_marker_reached), NULL);
</programlisting></informalexample>
In the example, the first callback will be invoked for both
the "foo" and "bar" marker, while the second and third callbacks
will be invoked for the "foo" or "bar" markers, respectively.
the name of the marker reached
the elapsed time
The ::new-frame signal is emitted for each timeline running
timeline before a new frame is drawn to give animations a chance
to update the scene.
the elapsed time between 0 and duration
The ::paused signal is emitted when clutter_timeline_pause() is invoked.
The ::started signal is emitted when the timeline starts its run.
This might be as soon as clutter_timeline_start() is invoked or
after the delay set in the ClutterTimeline:delay property has
expired.
The #ClutterTimelineClass structure contains only private data
The direction of a #ClutterTimeline
Creates a new timeout pool source. A timeout pool should be used when
multiple timeout functions, running at the same priority, are needed and
the g_timeout_add() API might lead to starvation of the time slice of
the main loop. A timeout pool allocates a single time slice of the main
loop and runs every timeout function inside it. The timeout pool is
always sorted, so that the extraction of the next timeout function is
a constant time operation.
is owned by the GLib default context and will be automatically
destroyed when the context is destroyed. It is possible to force
the destruction of the timeout pool using g_source_destroy()
the newly created #ClutterTimeoutPool. The created pool
the priority of the timeout pool. Typically this will be #G_PRIORITY_DEFAULT
Sets a function to be called at regular intervals, and puts it inside
the @pool. The function is repeatedly called until it returns %FALSE,
at which point the timeout is automatically destroyed and the function
won't be called again. If @notify is not %NULL, the @notify function
will be called. The first call to @func will be at the end of @interval.
Since Clutter 0.8 this will try to compensate for delays. For
example, if @func takes half the interval time to execute then the
function will be called again half the interval time after it
finished. Before version 0.8 it would not fire until a full
interval after the function completes so the delay between calls
would be @interval * 1.5. This function does not however try to
invoke the function multiple times to catch up missing frames if
Use clutter_timeout_pool_remove() to stop the timeout.
the ID (greater than 0) of the timeout inside the pool.
the time between calls to the function, in frames per second
function to call
data to pass to the function, or %NULL
function to call when the timeout is removed, or %NULL
Removes a timeout function with @id from the timeout pool. The id
is the same returned when adding a function to the timeout pool with
clutter_timeout_pool_add().
the id of the timeout to remove
The type of unit in which a value is expressed
This enumeration might be expanded at later date
An opaque structure, to be used to store sizing and positioning
values along with their unit.
Retrieves the unit type of the value stored inside @units
a unit type
Retrieves the value stored inside @units
the value stored inside a #ClutterUnits
Copies @units
Use clutter_units_free() to free the allocated resources
the newly created copy of a #ClutterUnits structure.
Frees the resources allocated by @units
You should only call this function on a #ClutterUnits
created using clutter_units_copy()
Stores a value in pixels inside @units
pixels
Stores a value in em inside @units, using the default font
name as returned by clutter_backend_get_font_name()
em
Stores a value in em inside @units using @font_name
the font name and size
em
Stores a value in millimiters inside @units
millimeters
Stores a value in centimeters inside @units
centimeters
Stores a value in typographic points inside @units
typographic points
Converts a value in #ClutterUnits to pixels
the value in pixels
Parses a value and updates @units with it
A #ClutterUnits expressed in string should match:
|[
| digit* sep digit+
]|
For instance, these are valid strings:
|[
10 px
5.1 em
24 pt
12.6 mm
.3 cm
]|
While these are not:
|[
42 cats
omg!1!ponies
]|
<note><para>If no unit is specified, pixels are assumed.</para></note>
and %FALSE otherwise
%TRUE if the string was successfully parsed,
the string to convert
Converts @units into a string
See clutter_units_from_string() for the units syntax and for
examples of output
<note>Fractional values are truncated to the second decimal
position for em, mm and cm, and to the first decimal position for
typographic points. Pixels are integers.</note>
#ClutterUnits value. Use g_free() to free the string
a newly allocated string containing the encoded
Vertex of an actor in 3D space, expressed in pixels
Creates a new #ClutterVertex for the point in 3D space
identified by the 3 coordinates @x, @y, @z
clutter_vertex_free() to free the resources
the newly allocate #ClutterVertex. Use
X coordinate
Y coordinate
Z coordinate
Copies @vertex
clutter_vertex_free() to free the allocated resources
a newly allocated copy of #ClutterVertex. Use
Frees a #ClutterVertex allocated using clutter_vertex_copy()
Compares @vertex_a and @vertex_b for equality
%TRUE if the passed #ClutterVertex are equal
a #ClutterVertex
Utility function for setting the source color of @cr using
a #ClutterColor.
a Cairo context
a #ClutterColor
Run-time version check, to check the version the Clutter library
that an application is currently linked against
This is the run-time equivalent of the compile-time %CLUTTER_CHECK_VERSION
pre-processor macro
greater than (@major, @minor, @micro), and %FALSE otherwise
%TRUE if the version of the Clutter library is
major version, like 1 in 1.2.3
minor version, like 2 in 1.2.3
micro version, like 3 in 1.2.3
Clears the internal cache of glyphs used by the Pango
renderer. This will free up some memory and GL texture
resources. The cache will be automatically refilled as more text is
drawn.
Compares two #ClutterColor<!-- -->s and checks if they are the same.
This function can be passed to g_hash_table_new() as the @key_equal_func
parameter, when using #ClutterColor<!-- -->s as keys in a #GHashTable.
%TRUE if the two colors are the same.
a #ClutterColor
a #ClutterColor
Converts a #ClutterColor to a hash value.
This function can be passed to g_hash_table_new() as the @hash_func
parameter, when using #ClutterColor<!-- -->s as keys in a #GHashTable.
a hash value corresponding to the color
a #ClutterColor
Looks up the #GParamSpec for a child property of @klass.
if no such property exist.
The #GParamSpec for the property or %NULL
a #GObjectClass implementing the #ClutterContainer interface.
a property name.
Returns an array of #GParamSpec for all child properties.
of #GParamSpec<!-- -->s which should be freed after use.
an array
a #GObjectClass implementing the #ClutterContainer interface.
return location for length of returned array.
Pops an event off the event queue. Applications should not need to call
this.
A #ClutterEvent or NULL if queue empty
Returns a pointer to the first event from the event queue but
does not remove it.
A #ClutterEvent or NULL if queue empty.
Checks if events are pending in the event queue.
TRUE if there are pending events, FALSE otherwise.
Checks whether @feature is available. @feature can be a logical
OR of #ClutterFeatureFlags.
%TRUE if a feature is available
a #ClutterFeatureFlags
Returns all the supported features.
a logical OR of all the supported features.
Simple wrapper around clutter_frame_source_add_full().
the ID (greater than 0) of the event source.
the number of times per second to call the function
function to call
data to pass to the function
Sets a function to be called at regular intervals with the given
priority. The function is called repeatedly until it returns
%FALSE, at which point the timeout is automatically destroyed and
the function will not be called again. The @notify function is
called when the timeout is destroyed. The first call to the
function will be at the end of the first @interval.
This function is similar to g_timeout_add_full() except that it
will try to compensate for delays. For example, if @func takes half
the interval time to execute then the function will be called again
half the interval time after it finished. In contrast
g_timeout_add_full() would not fire until a full interval after the
function completes so the delay between calls would be 1.0 / @fps *
1.5. This function does not however try to invoke the function
multiple times to catch up missing frames if @func takes more than
the ID (greater than 0) of the event source.
the priority of the frame source. Typically this will be in the range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
the number of times per second to call the function
function to call
data to pass to the function
function to call when the timeout source is removed
Returns whether Clutter has accessibility support enabled. As
least, a value of TRUE means that there are a proper AtkUtil
implementation available
%TRUE if Clutter has accessibility support enabled
If an event is currently being processed, return that event.
This function is intended to be used to access event state
that might not be exposed by higher-level widgets. For
example, to get the key modifier state from a Button 'clicked'
event.
The current ClutterEvent, or %NULL if none
Retrieves the timestamp of the last event, if there is an
event or if the event has a timestamp.
the event timestamp, or %CLUTTER_CURRENT_TIME
Check if clutter has debugging turned on.
TRUE if debugging is turned on, FALSE otherwise.
Retrieves the default #ClutterBackend used by Clutter. The
#ClutterBackend holds backend-specific configuration options.
not ref or unref the returned object. Applications should rarely
need to use this.
the default backend. You should
Retrieves the default frame rate. See clutter_set_default_frame_rate().
the default frame rate
Retrieves the default direction for the text. The text direction is
determined by the locale and/or by the %CLUTTER_TEXT_DIRECTION environment
variable
The default text direction can be overridden on a per-actor basis by using
clutter_actor_set_text_direction()
the default text direction
Gets the current font flags for rendering text. See
clutter_set_font_flags().
The font flags
Retrieves the #PangoFontMap instance used by Clutter.
You can use the global font map object with the COGL
Pango API.
value is owned by Clutter and it should never be unreferenced.
the #PangoFontMap instance. The returned
Retrieves the #ClutterInputDevice from its @id. This is a convenience
wrapper for clutter_device_manager_get_device() and it is functionally
equivalent to:
|[
ClutterDeviceManager *manager;
ClutterInputDevice *device;
manager = clutter_device_manager_get_default ();
device = clutter_device_manager_get_device (manager, id);
]|
a #ClutterInputDevice, or %NULL
the unique id for a device
Queries the current keyboard grab of clutter.
the actor currently holding the keyboard grab, or NULL if there is no grab.
Gets whether the per-actor motion events are enabled.
%TRUE if the motion events are enabled
Returns a #GOptionGroup for the command line arguments recognized
by Clutter. You should add this group to your #GOptionContext with
g_option_context_add_group(), if you are using g_option_context_parse()
to parse your commandline arguments.
Calling g_option_context_parse() with Clutter's #GOptionGroup will result
in Clutter's initialization. That is, the following code:
|[
g_option_context_set_main_group (context, clutter_get_option_group ());
res = g_option_context_parse (context, &argc, &argc, NULL);
]|
is functionally equivalent to:
|[
clutter_init (&argc, &argv);
]|
After g_option_context_parse() on a #GOptionContext containing the
Clutter #GOptionGroup has returned %TRUE, Clutter is guaranteed to be
initialized.
recognized by Clutter
a #GOptionGroup for the commandline arguments
Returns a #GOptionGroup for the command line arguments recognized
by Clutter. You should add this group to your #GOptionContext with
g_option_context_add_group(), if you are using g_option_context_parse()
to parse your commandline arguments. Unlike clutter_get_option_group(),
calling g_option_context_parse() with the #GOptionGroup returned by this
function requires a subsequent explicit call to clutter_init(); use this
function when needing to set foreign display connection with
clutter_x11_set_display(), or with gtk_clutter_init().
recognized by Clutter
a #GOptionGroup for the commandline arguments
Queries the current pointer grab of clutter.
the actor currently holding the pointer grab, or NULL if there is no grab.
Retrieves the Clutter script id, if any.
a UI definition file. The returned string is owned by the object and
should never be modified or freed.
the script id, or %NULL if @object was not defined inside
a #GObject
Returns whether Clutter should print out the frames per second on the
console. You can enable this setting either using the
<literal>CLUTTER_SHOW_FPS</literal> environment variable or passing
the <literal>--clutter-show-fps</literal> command line argument. *
%TRUE if Clutter should show the FPS.
Returns the approximate number of microseconds passed since clutter was
intialised.
Number of microseconds since clutter_init() was called.
Grabs keyboard events, after the grab is done keyboard
events (#ClutterActor::key-press-event and #ClutterActor::key-release-event)
are delivered to this actor directly. The source set in the event will be
the actor that would have received the event if the keyboard grab was not
in effect.
Like pointer grabs, keyboard grabs should only be used as a last
resource.
See also clutter_stage_set_key_focus() and clutter_actor_grab_key_focus()
to perform a "soft" key grab and assign key focus to a specific actor.
a #ClutterActor
Grabs pointer events, after the grab is done all pointer related events
(press, motion, release, enter, leave and scroll) are delivered to this
actor directly without passing through both capture and bubble phases of
the event delivery chain. The source set in the event will be the actor
that would have received the event if the pointer grab was not in effect.
<note><para>Grabs completely override the entire event delivery chain
done by Clutter. Pointer grabs should only be used as a last resource;
using the #ClutterActor::captured-event signal should always be the
preferred way to intercept event delivery to reactive actors.</para></note>
If you wish to grab all the pointer events for a specific input device,
you should use clutter_grab_pointer_for_device().
a #ClutterActor
Grabs all the pointer events coming from the device @id for @actor.
If @id is -1 then this function is equivalent to clutter_grab_pointer().
a #ClutterActor
a device id, or -1
It will initialise everything needed to operate with Clutter and
parses some standard command line options. @argc and @argv are
adjusted accordingly so your own code will never see those standard
arguments.
1 on success, < 0 on failure.
The number of arguments in @argv
A pointer to an array of arguments.
This function does the same work as clutter_init(). Additionally,
it allows you to add your own command line options, and it
automatically generates nicely formatted <option>--help</option>
output. Note that your program will be terminated after writing
out the help output. Also note that, in case of error, the
error message will be placed inside @error instead of being
printed on the display.
initialised, or other values or #ClutterInitError in case of
error.
%CLUTTER_INIT_SUCCESS if Clutter has been successfully
a pointer to the number of command line arguments
a pointer to the array of command line arguments
a string which is displayed in the first line of <option>--help</option> output, after <literal><replaceable>programname</replaceable> [OPTION...]</literal>
a %NULL terminated array of #GOptionEntry<!-- -->s describing the options of your program
a translation domain to use for translating the <option>--help</option> output for the options in
Convert from a Clutter key symbol to the corresponding ISO10646 (Unicode)
character.
character.
a Unicode character, or 0 if there is no corresponding
a key symbol
Starts the Clutter mainloop.
Retrieves the depth of the Clutter mainloop.
The level of the mainloop.
Terminates the Clutter mainloop.
Creates a #GParamSpec for properties using #ClutterColor.
the newly created #GParamSpec
name of the property
short name
description (can be translatable)
default value
flags for the param spec
Creates a #GParamSpec for properties using #CoglFixed values
the newly created #GParamSpec
name of the property
short name
description (can be translatable)
lower boundary
higher boundary
default value
flags for the param spec
Creates a #GParamSpec for properties using #ClutterUnits.
the newly created #GParamSpec
name of the property
short name
description (can be translatable)
the default type for the #ClutterUnits
lower boundary
higher boundary
default value
flags for the param spec
Forces a redraw of the entire stage. Applications should never use this
function, but queue a redraw using clutter_actor_queue_redraw().
This function should only be used by libraries integrating Clutter from
within another toolkit.
Sets the default frame rate. This frame rate will be used to limit
the number of frames drawn if Clutter is not able to synchronize
with the vertical refresh rate of the display. When synchronization
is possible, this value is ignored.
the new default frame rate
Sets the font quality options for subsequent text rendering
operations.
Using mipmapped textures will improve the quality for scaled down
text but will use more texture memory.
Enabling hinting improves text quality for static text but may
introduce some artifacts if the text is animated.
The new flags
Sets whether per-actor motion events should be enabled or not (the
default is to enable them).
If @enable is %FALSE the following events will not work:
<itemizedlist>
<listitem><para>ClutterActor::motion-event, unless on the
#ClutterStage</para></listitem>
<listitem><para>ClutterActor::enter-event</para></listitem>
<listitem><para>ClutterActor::leave-event</para></listitem>
</itemizedlist>
%TRUE to enable per-actor motion events
Simple wrapper around clutter_threads_add_frame_source_full().
the ID (greater than 0) of the event source.
the number of times per second to call the function
function to call
data to pass to the function
Sets a function to be called at regular intervals holding the Clutter
threads lock, with the given priority. The function is called repeatedly
until it returns %FALSE, at which point the timeout is automatically
removed and the function will not be called again. The @notify function
is called when the timeout is removed.
This function is similar to clutter_threads_add_timeout_full()
except that it will try to compensate for delays. For example, if
will be called again half the interval time after it finished. In
contrast clutter_threads_add_timeout_full() would not fire until a
full interval after the function completes so the delay between
calls would be @interval * 1.5. This function does not however try
to invoke the function multiple times to catch up missing frames if
See also clutter_threads_add_idle_full().
the ID (greater than 0) of the event source.
the priority of the frame source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
the number of times per second to call the function
function to call
data to pass to the function
function to call when the timeout source is removed
Simple wrapper around clutter_threads_add_idle_full() using the
default priority.
the ID (greater than 0) of the event source.
function to call
data to pass to the function
Adds a function to be called whenever there are no higher priority
events pending. If the function returns %FALSE it is automatically
removed from the list of event sources and will not be called again.
This function can be considered a thread-safe variant of g_idle_add_full():
it will call @function while holding the Clutter lock. It is logically
equivalent to the following implementation:
|[
static gboolean
idle_safe_callback (gpointer data)
{
SafeClosure *closure = data;
gboolean res = FALSE;
/* mark the critical section */
clutter_threads_enter();
/* the callback does not need to acquire the Clutter
* lock itself, as it is held by the this proxy handler
*/
res = closure->callback (closure->data);
clutter_threads_leave();
return res;
}
static gulong
add_safe_idle (GSourceFunc callback,
gpointer data)
{
SafeClosure *closure = g_new0 (SafeClosure, 1);
closure->callback = callback;
closure->data = data;
return g_add_idle_full (G_PRIORITY_DEFAULT_IDLE,
idle_safe_callback,
closure,
g_free)
}
]|
This function should be used by threaded applications to make sure
that @func is emitted under the Clutter threads lock and invoked
from the same thread that started the Clutter main loop. For instance,
it can be used to update the UI using the results from a worker
thread:
|[
static gboolean
update_ui (gpointer data)
{
SomeClosure *closure = data;
/* it is safe to call Clutter API from this function because
* it is invoked from the same thread that started the main
* loop and under the Clutter thread lock
*/
clutter_label_set_text (CLUTTER_LABEL (closure->label),
closure->text);
g_object_unref (closure->label);
g_free (closure);
return FALSE;
}
/* within another thread */
closure = g_new0 (SomeClosure, 1);
/* always take a reference on GObject instances */
closure->label = g_object_ref (my_application->label);
closure->text = g_strdup (processed_text_to_update_the_label);
clutter_threads_add_idle_full (G_PRIORITY_HIGH_IDLE,
update_ui,
closure,
NULL);
]|
the ID (greater than 0) of the event source.
the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE
function to call
data to pass to the function
functio to call when the idle source is removed
Adds a function to be called whenever Clutter is repainting a Stage.
If the function returns %FALSE it is automatically removed from the
list of repaint functions and will not be called again.
This function is guaranteed to be called from within the same thread
that called clutter_main(), and while the Clutter lock is being held.
A repaint function is useful to ensure that an update of the scenegraph
is performed before the scenegraph is repainted; for instance, uploading
a frame from a video into a #ClutterTexture.
When the repaint function is removed (either because it returned %FALSE
or because clutter_threads_remove_repaint_func() has been called) the
can use the returned integer to remove the repaint function by
calling clutter_threads_remove_repaint_func().
the ID (greater than 0) of the repaint function. You
the function to be called within the paint cycle
data to be passed to the function, or %NULL
function to be called when removing the repaint function, or %NULL
Simple wrapper around clutter_threads_add_timeout_full().
the ID (greater than 0) of the event source.
the time between calls to the function, in milliseconds
function to call
data to pass to the function
Sets a function to be called at regular intervals holding the Clutter
threads lock, with the given priority. The function is called repeatedly
until it returns %FALSE, at which point the timeout is automatically
removed and the function will not be called again. The @notify function
is called when the timeout is removed.
The first call to the function will be at the end of the first @interval.
It is important to note that, due to how the Clutter main loop is
implemented, the timing will not be accurate and it will not try to
"keep up" with the interval. A more reliable source is available
using clutter_threads_add_frame_source_full(), which is also internally
used by #ClutterTimeline.
See also clutter_threads_add_idle_full().
the ID (greater than 0) of the event source.
the priority of the timeout source. Typically this will be in the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
the time between calls to the function, in milliseconds
function to call
data to pass to the function
function to call when the timeout source is removed
Locks the Clutter thread lock.
Initialises the Clutter threading mechanism, so that Clutter API can be
called by multiple threads, using clutter_threads_enter() and
clutter_threads_leave() to mark the critical sections.
You must call g_thread_init() before this function.
This function must be called before clutter_init().
It is safe to call this function multiple times.
Unlocks the Clutter thread lock.
Removes the repaint function with @handle_id as its id
an unsigned integer greater than zero
Allows the application to replace the standard method that
Clutter uses to protect its data structures. Normally, Clutter
creates a single #GMutex that is locked by clutter_threads_enter(),
and released by clutter_threads_leave(); using this function an
application provides, instead, a function @enter_fn that is
called by clutter_threads_enter() and a function @leave_fn that is
called by clutter_threads_leave().
The functions must provide at least same locking functionality
as the default implementation, but can also do extra application
specific processing.
As an example, consider an application that has its own recursive
lock that when held, holds the Clutter lock as well. When Clutter
unlocks the Clutter lock when entering a recursive main loop, the
application must temporarily release its lock as well.
Most threaded Clutter apps won't need to use this method.
This method must be called before clutter_threads_init(), and cannot
be called multiple times.
function called when aquiring the Clutter main lock
function called when releasing the Clutter main lock
Removes an existing grab of the keyboard.
Removes an existing grab of the pointer.
Removes an existing grab of the pointer events for device @id.
a device id
Calculates the nearest power of two, greater than or equal to @a.
The nearest power of two, greater or equal to @a.
Value to get the next power
Gets the #ClutterColor contained in @value.
the colors inside the passed #GValue
a #GValue initialized to #CLUTTER_TYPE_COLOR
Gets the fixed point value stored inside @value.
the value inside the passed #GValue
a #GValue initialized to %COGL_TYPE_FIXED
Retrieves the list of floating point values stored inside
the passed #GValue. @value must have been initialized with
%CLUTTER_TYPE_SHADER_FLOAT.
The returned value is owned by the #GValue and should never
be modified or freed.
the pointer to a list of floating point values.
a #GValue
return location for the number of returned floating point values, or %NULL
Retrieves the list of integer values stored inside the passed
#GValue. @value must have been initialized with
%CLUTTER_TYPE_SHADER_INT.
The returned value is owned by the #GValue and should never
be modified or freed.
the pointer to a list of integer values.
a #GValue
return location for the number of returned integer values, or %NULL
Retrieves a matrix of floating point values stored inside
the passed #GValue. @value must have been initialized with
%CLUTTER_TYPE_SHADER_MATRIX.
of floating point values. The returned value is owned by the #GValue and
should never be modified or freed.
the pointer to a matrix
a #GValue
return location for the number of returned floating point values, or %NULL
Gets the #ClutterUnit<!-- -->s contained in @value.
the units inside the passed #GValue
a #GValue initialized to #CLUTTER_TYPE_UNIT
Sets @value to @color.
a #GValue initialized to #CLUTTER_TYPE_COLOR
the color to set
Sets @value to @fixed_.
a #GValue initialized to %COGL_TYPE_FIXED
the fixed point value to set
Sets @floats as the contents of @value. The passed #GValue
must have been initialized using %CLUTTER_TYPE_SHADER_FLOAT.
a #GValue
number of floating point values in @floats
an array of floating point values
Sets @ints as the contents of @value. The passed #GValue
must have been initialized using %CLUTTER_TYPE_SHADER_INT.
a #GValue
number of integer values in @ints
an array of integer values
Sets @matrix as the contents of @value. The passed #GValue
must have been initialized using %CLUTTER_TYPE_SHADER_MATRIX.
a #GValue
number of floating point values in @floats
a matrix of floating point values
Sets @value to @units
a #GValue initialized to #CLUTTER_TYPE_UNIT
the units to set