A simple macro for initializing a #ClutterActorBox when declaring it, e.g.: ```c ClutterActorBox box = CLUTTER_ACTOR_BOX_INIT (0, 0, 400, 600); ```

the X coordinate of the top left corner the Y coordinate of the top left corner the X coordinate of the bottom right corner the Y coordinate of the bottom right corner

Abstract class for event-related logic #ClutterAction is an abstract base class for event-related actions that modify the user interaction of a [class@Actor], just like [class@Constraint] is an abstract class for modifiers of an actor's position or size. Implementations of #ClutterAction are associated to an actor and can provide behavioral changes when dealing with user input - for instance drag and drop capabilities, or scrolling, or panning - by using the various event-related signals provided by [class@Actor] itself.

The ClutterActionClass structure contains only private data

The basic element of the scene graph The ClutterActor class is the basic element of the scene graph in Clutter, and it encapsulates the position, size, and transformations of a node in the graph. ## Actor transformations Each actor can be transformed using methods like [method@Actor.set_scale] or [method@Actor.set_rotation_angle]. The order in which the transformations are applied is decided by Clutter and it is the following: 1. translation by the origin of the [property@Actor:allocation] property 2. translation by the actor's [property@Actor:z-position] property 3. translation by the actor's [property@Actor:pivot-point] property 4. scaling by the [property@Actor:scale-x] and [property@Actor:scale-y] factors 5. rotation around the [property@Actor:rotation-angle-x] 6. rotation around the [property@Actor:rotation-angle-y] 7. rotation around the [property@Actor:rotation-angle-z] 8. negative translation by the actor's [property@Actor:pivot-point] ## Modifying an actor's geometry Each actor has a bounding box, called [property@Actor:allocation] which is either set by its parent or explicitly through the [method@Actor.set_position] and [method@Actor.set_size] methods. Each actor also has an implicit preferred size. An actor’s preferred size can be defined by any subclass by overriding the [vfunc@Actor.get_preferred_width] and the [vfunc@Actor.get_preferred_height] virtual functions, or it can be explicitly set by using [method@Actor.set_width] and [method@Actor.set_height]. An actor’s position can be set explicitly by using [method@Actor.set_x] and [method@Actor.set_y]; the coordinates are relative to the origin of the actor’s parent. ## Managing actor children Each actor can have multiple children, by calling [method@Clutter.Actor.add_child] to add a new child actor, and [method@Clutter.Actor.remove_child] to remove an existing child. #ClutterActor will hold a reference on each child actor, which will be released when the child is removed from its parent, or destroyed using [method@Clutter.Actor.destroy]. ```c ClutterActor *actor = clutter_actor_new (); // set the bounding box of the actor clutter_actor_set_position (actor, 0, 0); clutter_actor_set_size (actor, 480, 640); // set the background color of the actor clutter_actor_set_background_color (actor, &COGL_COLOR_INIT (0xf5, 0x79, 0x00, 0xff)); // set the bounding box of the child, relative to the parent ClutterActor *child = clutter_actor_new (); clutter_actor_set_position (child, 20, 20); clutter_actor_set_size (child, 80, 240); // set the background color of the child clutter_actor_set_background_color (child, &COGL_COLOR_INIT (0x00, 0x00, 0xff, 0xff)); // add the child to the actor clutter_actor_add_child (actor, child); ``` Children can be inserted at a given index, or above and below another child actor. The order of insertion determines the order of the children when iterating over them. Iterating over children is performed by using [method@Clutter.Actor.get_first_child], [method@Clutter.Actor.get_previous_sibling], [method@Clutter.Actor.get_next_sibling], and [method@Clutter.Actor.get_last_child]. It is also possible to retrieve a list of children by using [method@Clutter.Actor.get_children], as well as retrieving a specific child at a given index by using [method@Clutter.Actor.get_child_at_index]. If you need to track additions of children to a [type@Clutter.Actor], use the [signal@Clutter.Actor::child-added] signal; similarly, to track removals of children from a ClutterActor, use the [signal@Clutter.Actor::child-removed] signal. ## Painting an actor There are three ways to paint an actor: - set a delegate #ClutterContent as the value for the [property@Clutter.Actor:content] property of the actor - subclass #ClutterActor and override the [vfunc@Clutter.Actor.paint_node] virtual function - subclass #ClutterActor and override the [vfunc@Clutter.Actor.paint] virtual function. A #ClutterContent is a delegate object that takes over the painting operations of one, or more actors. The #ClutterContent painting will be performed on top of the [property@Clutter.Actor:background-color] of the actor, and before calling the actor's own implementation of the [vfunc@Clutter.Actor.paint_node] virtual function. ```c ClutterActor *actor = clutter_actor_new (); // set the bounding box clutter_actor_set_position (actor, 50, 50); clutter_actor_set_size (actor, 100, 100); // set the content; the image_content variable is set elsewhere clutter_actor_set_content (actor, image_content); ``` The [vfunc@Clutter.Actor.paint_node] virtual function is invoked whenever an actor needs to be painted. The implementation of the virtual function must only paint the contents of the actor itself, and not the contents of its children, if the actor has any. The #ClutterPaintNode passed to the virtual function is the local root of the render tree; any node added to it will be rendered at the correct position, as defined by the actor's [property@Clutter.Actor:allocation]. ```c static void my_actor_paint_node (ClutterActor *actor, ClutterPaintNode *root) { ClutterPaintNode *node; ClutterActorBox box; // where the content of the actor should be painted clutter_actor_get_allocation_box (actor, &box); // the cogl_texture variable is set elsewhere node = clutter_texture_node_new (cogl_texture, &COGL_COLOR_INIT (255, 255, 255, 255), CLUTTER_SCALING_FILTER_TRILINEAR, CLUTTER_SCALING_FILTER_LINEAR); // paint the content of the node using the allocation clutter_paint_node_add_rectangle (node, &box); // add the node, and transfer ownership clutter_paint_node_add_child (root, node); clutter_paint_node_unref (node); } ``` The [vfunc@Clutter.Actor.paint] virtual function function gives total control to the paint sequence of the actor itself, including the children of the actor, if any. It is strongly discouraged to override the [vfunc@Clutter.Actor.paint] virtual function and it will be removed when the Clutter API changes. ## Handling events on an actor A #ClutterActor can receive and handle input device events, for instance pointer events and key events, as long as its [property@Clutter.Actor:reactive] property is set to %TRUE. Once an actor has been determined to be the source of an event, Clutter will traverse the scene graph from the top-level actor towards the event source, emitting the [signal@Clutter.Actor::captured-event] signal on each ancestor until it reaches the source; this phase is also called the "capture" phase. If the event propagation was not stopped, the graph is walked backwards, from the source actor to the top-level, and the [signal@Clutter.Actor::event signal] is emitted, alongside eventual event-specific signals like [signal@Clutter.Actor::button-press-event] or [signal@Clutter.Actor::motion-event]; this phase is also called the "bubble" phase. At any point of the signal emission, signal handlers can stop the propagation through the scene graph by returning %CLUTTER_EVENT_STOP; otherwise, they can continue the propagation by returning %CLUTTER_EVENT_PROPAGATE. ## Animation Animation is a core concept of modern user interfaces; Clutter provides a complete and powerful animation framework that automatically tweens the actor's state without requiring direct, frame by frame manipulation from your application code. You have two models at your disposal: - an implicit animation model - an explicit animation model The implicit animation model of Clutter assumes that all the changes in an actor state should be gradual and asynchronous; Clutter will automatically transition an actor's property change between the current state and the desired one without manual intervention, if the property is defined to be animatable in its documentation. By default, in the 1.0 API series, the transition happens with a duration of zero milliseconds, and the implicit animation is an opt in feature to retain backwards compatibility. Implicit animations depend on the current easing state; in order to use the default easing state for an actor you should call the [method@Clutter.Actor.save_easing_state] function: ```c // assume that the actor is currently positioned at (100, 100) // store the current easing state and reset the new easing state to // its default values clutter_actor_save_easing_state (actor); // change the actor's position clutter_actor_set_position (actor, 500, 500); // restore the previously saved easing state clutter_actor_restore_easing_state (actor); ``` The example above will trigger an implicit animation of the actor between its current position to a new position. Implicit animations use a default duration of 250 milliseconds, and a default easing mode of %CLUTTER_EASE_OUT_CUBIC, unless you call [method@Clutter.Actor.set_easing_mode] and [method@Clutter.Actor.set_easing_duration] after changing the easing state of the actor. It is possible to animate multiple properties of an actor at the same time, and you can animate multiple actors at the same time as well, for instance: ```c clutter_actor_save_easing_state (actor); // animate the actor's opacity and depth clutter_actor_set_opacity (actor, 0); clutter_actor_set_z_position (actor, -100); clutter_actor_restore_easing_state (actor); clutter_actor_save_easing_state (another_actor); // animate another actor's opacity clutter_actor_set_opacity (another_actor, 255); clutter_actor_set_z_position (another_actor, 100); clutter_actor_restore_easing_state (another_actor); ``` Changing the easing state will affect all the following property transitions, but will not affect existing transitions. It is important to note that if you modify the state on an animatable property while a transition is in flight, the transition's final value will be updated, as well as its duration and progress mode by using the current easing state; for instance, in the following example: ```c clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 1000); clutter_actor_set_x (actor, 200); clutter_actor_restore_easing_state (actor); clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_x (actor, 100); clutter_actor_restore_easing_state (actor); ``` the first call to [method@Clutter.Actor.set_x] will begin a transition of the [property@Clutter.Actor:x] property from the current value to the value of 200 over a duration of one second; the second call to [method@Clutter.Actor.set_x] will change the transition's final value to 100 and the duration to 500 milliseconds. It is possible to receive a notification of the completion of an implicit transition by using the [signal@Clutter.Actor::transition-stopped] signal, decorated with the name of the property. In case you want to know when all the currently in flight transitions are complete, use the [signal@Clutter.Actor::transitions-completed] signal instead. It is possible to retrieve the [class@Clutter.Transition] used by the animatable properties by using [method@Clutter.Actor.get_transition] and using the property name as the transition name. The explicit animation model supported by Clutter requires that you create a #ClutterTransition object, and optionally set the initial and final values. The transition will not start unless you add it to the #ClutterActor. ```c ClutterTransition *transition; transition = clutter_property_transition_new_for_actor (actor, "opacity"); clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 3000); clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), 2); clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE); clutter_transition_set_from (transition, G_TYPE_UINT, 255); clutter_transition_set_to (transition, G_TYPE_UINT, 0); clutter_actor_add_transition (actor, "animate-opacity", transition); ``` The example above will animate the [property@Clutter.Actor:opacity] property of an actor between fully opaque and fully transparent, and back, over a span of 3 seconds. The animation does not begin until it is added to the actor. The explicit animation API applies to all #GObject properties, as well as the custom properties defined through the [iface@Clutter.Animatable] interface, regardless of whether they are defined as implicitly animatable or not. The explicit animation API should also be used when using custom animatable properties for [class@Clutter.Action], [class@Clutter.Constraint], and [class@Clutter.Effect] instances associated to an actor; see the section on custom animatable properties below for an example. Finally, explicit animations are useful for creating animations that run continuously, for instance: ```c // this animation will pulse the actor's opacity continuously ClutterTransition *transition; ClutterInterval *interval; transition = clutter_property_transition_new_for_actor (actor, "opacity"); // we want to animate the opacity between 0 and 255 clutter_transition_set_from (transition, G_TYPE_UINT, 0); clutter_transition_set_to (transition, G_TYPE_UINT, 255); // over a one second duration, running an infinite amount of times clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 1000); clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), -1); // we want to fade in and out, so we need to auto-reverse the transition clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE); // and we want to use an easing function that eases both in and out clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (transition), CLUTTER_EASE_IN_OUT_CUBIC); // add the transition to the desired actor to start it clutter_actor_add_transition (actor, "opacityAnimation", transition); ``` ## Implementing an actor Careful consideration should be given when deciding to implement a #ClutterActor sub-class. It is generally recommended to implement a sub-class of #ClutterActor only for actors that should be used as leaf nodes of a scene graph. By overriding the [vfunc@Clutter.Actor.get_preferred_width] and [vfunc@Clutter.Actor.get_preferred_height] virtual functions it is possible to change or provide the preferred size of an actor; similarly, by overriding the [vfunc@Clutter.Actor.allocate] virtual function it is possible to control the layout of the children of an actor. Make sure to always chain up to the parent implementation of the [vfunc@Clutter.Actor.allocate] virtual function. In general, it is strongly encouraged to use delegation and composition instead of direct subclassing. ## Custom animatable properties #ClutterActor allows accessing properties of [class@Clutter.Action], [class@Clutter.Effect], and [class@Clutter.Constraint] instances associated to an actor instance for animation purposes, as well as its [class@Clutter.LayoutManager]. In order to access a specific [class@Clutter.Action] or a [class@Clutter.Constraint] property it is necessary to set the [property@Clutter.ActorMeta:name] property on the given action or constraint. The property can be accessed using the following syntax: ``` @<section>.<meta-name>.<property-name> ``` - the initial `@` is mandatory - the `section` fragment can be one between "actions", "constraints", "content", and "effects" - the `meta-name` fragment is the name of the action, effect, or constraint, as specified by the #ClutterActorMeta:name property of #ClutterActorMeta - the `property-name` fragment is the name of the action, effect, or constraint property to be animated. The example below animates a [class@Clutter.BindConstraint] applied to an actor using an explicit transition. The `rect` actor has a binding constraint on the `origin` actor, and in its initial state is overlapping the actor to which is bound to. As the actor has only one [class@Clutter.LayoutManager], the syntax for accessing its properties is simpler: ``` @layout.<property-name> ``` ```c constraint = clutter_bind_constraint_new (origin, CLUTTER_BIND_X, 0.0); clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), "bind-x"); clutter_actor_add_constraint (rect, constraint); constraint = clutter_bind_constraint_new (origin, CLUTTER_BIND_Y, 0.0); clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), "bind-y"); clutter_actor_add_constraint (rect, constraint); clutter_actor_set_reactive (origin, TRUE); g_signal_connect (origin, "button-press-event", G_CALLBACK (on_button_press), rect); ``` On button press, the rectangle "slides" from behind the actor to which is bound to, using the #ClutterBindConstraint:offset property to achieve the effect: ```c gboolean on_button_press (ClutterActor *origin, ClutterEvent *event, ClutterActor *rect) { ClutterTransition *transition; // the offset that we want to apply; this will make the actor // slide in from behind the origin and rest at the right of // the origin, plus a padding value float new_offset = clutter_actor_get_width (origin) + h_padding; // the property we wish to animate; the "@constraints" section // tells Clutter to check inside the constraints associated // with the actor; the "bind-x" section is the name of the // constraint; and the "offset" is the name of the property // on the constraint const char *prop = "@constraints.bind-x.offset"; // create a new transition for the given property transition = clutter_property_transition_new_for_actor (rect, prop); // set the easing mode and duration clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (transition), CLUTTER_EASE_OUT_CUBIC); clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 500); // create the interval with the initial and final values clutter_transition_set_from (transition, G_TYPE_FLOAT, 0.f); clutter_transition_set_to (transition, G_TYPE_FLOAT, new_offset); // add the transition to the actor; this causes the animation // to start. the name "offsetAnimation" can be used to retrieve // the transition later clutter_actor_add_transition (rect, "offsetAnimation", transition); // we handled the event return CLUTTER_EVENT_STOP; } ```

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

the newly created #ClutterActor

Assigns the size of a #ClutterActor from the given @box. This function should only be called on the children of an actor when overriding the [vfunc@Clutter.Actor.allocate] virtual function. This function will adjust the stored allocation to take into account the alignment flags set in the [property@Clutter.Actor:x-align] and [property@Clutter.Actor:y-align] properties, as well as the margin values set in the[property@Clutter.Actor:margin-top], [property@Clutter.Actor:margin-right], [property@Clutter.Actor:margin-bottom], and [property@Clutter.Actor:margin-left] properties. This function will respect the easing state of the #ClutterActor and interpolate between the current allocation and the new one if the easing state duration is a positive value. Actors can know from their allocation box whether they have moved with respect to their parent actor. The @flags parameter describes additional information about the allocation, for instance whether the parent has moved with respect to the stage, for example because a grandparent's origin has moved.

A #ClutterActor

new allocation of the actor, in parent-relative coordinates

virtual function, used when applying the transformations to an actor before painting it or when transforming coordinates or the allocation; if the transformation calculated by this function may have changed, the cached transformation must be invalidated by calling clutter_actor_invalidate_transform(); it must chain up to the parent's implementation

class handler for [signal@Clutter.Actor::button-press-event]

class handler for [signal@Clutter.Actor::button-release-event]

signal class closure for [signal@Clutter.Actor::captured-event]

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.

a #ClutterActor

signal class closure for [signal@Clutter.Actor::enter-event]

class handler for [signal@Clutter.Actor::event]

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 [https://gnome.pages.gitlab.gnome.org/at-spi2-core/atk/](ATK) library contains more information about accessible objects and their uses.

the #AtkObject associated with @actor

a #ClutterActor

virtual function, for sub-classes to define their #ClutterPaintVolume

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 translation; those transformations do not affect layout, only rendering.

A #ClutterActor

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 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 scaleor translation; those transformations do not affect layout, only rendering.

A #ClutterActor

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

Asks the actor's implementation whether it may contain overlapping primitives. For example; Clutter may use this to determine whether the painting should be redirected to an offscreen buffer to correctly implement the opacity property. Custom actors can override the default response by implementing the [vfunc@Clutter.Actor.has_overlaps]. See [method@Clutter.Actor.set_offscreen_redirect] for more information.

%TRUE if the actor may have overlapping primitives, and %FALSE otherwise

A #ClutterActor

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

A #ClutterActor

virtual function for containers and composite actors, to determine which children should be shown when calling clutter_actor_hide_all() on the actor. Defaults to calling clutter_actor_hide(). This virtual function is deprecated and it should not be overridden.

signal class closure for [signal@Clutter.Actor::key-focus-in]

signal class closure for [signal@Clutter.Actor::key-focus-out]

signal class closure for [signal@Clutter.Actor::key-press-event]

signal class closure for [signal@Clutter.Actor::key-release-event]

signal class closure for [signal@Clutter.Actor::leave-event]

Sets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly maps and realizes its children if they are visible. Does nothing if the actor is not visible. Calling this function is strongly discouraged: the default implementation of [vfunc@Clutter.Actor.map] will map all the children of an actor when mapping its parent. When overriding map, it is mandatory to chain up to the parent implementation.

A #ClutterActor

signal class closure for [signal@Clutter.Actor::motion-event]

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 call the [vfunc@Clutter.Actor.paint] virtual function. This function does not paint the actor if the actor is set to 0, unless it is performing a pick paint.

A #ClutterActor

virtual function for creating paint nodes and attaching them to the render tree

signal class handler for the [signal@Clutter.Actor::parent-set]

Asks @actor to perform a pick.

A #ClutterActor

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.

A #ClutterActor

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.

Actors are automatically realized, and nothing requires explicit realization.

A #ClutterActor

signal class closure for [signal@Clutter.Actor::scroll-event]

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

A #ClutterActor

signal class closure for [signal@Clutter.Actor::touch-event]

Unsets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly unmaps its children if they were mapped. Calling this function is not encouraged: the default #ClutterActor implementation of [vfunc@Clutter.Actor.unmap] will also unmap any eventual children by default when their parent is unmapped. When overriding [vfunc@Clutter.Actor.unmap], it is mandatory to chain up to the parent implementation. It is important to note that the implementation of the [vfunc@Clutter.Actor.unmap] virtual function may be called after the [vfunc@Clutter.Actor.destroy] or the [vfunc@GObject.Object.dispose] implementation, but it is guaranteed to be called before the [vfunc@GObject.Object.finalize] implementation.

A #ClutterActor

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

Actors are automatically unrealized, and nothing requires explicit realization.

A #ClutterActor

This method adds @state as one of the accessible states for @actor. The list of states of an actor describes the current state of user interface element @actor and is provided so that assistive technologies know how to present @actor to the user. Usually you will have no need to add accessible states for an object, as the accessible object can extract most of the states from the object itself. This method is only required when one cannot extract the information automatically from the object itself (i.e.: a generic container used as a toggle menu item will not automatically include the toggled state).

A #ClutterActor

#AtkStateType state to add

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 [method@Clutter.Actor.remove_action] or [method@Clutter.Actor.clear_actions] is called

a #ClutterActor

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: ```c clutter_actor_meta_set_name (CLUTTER_ACTOR_META (action), name); clutter_actor_add_action (self, action); ```

a #ClutterActor

the name to set on the action a #ClutterAction

Adds @child to the children of @self. This function will acquire a reference on @child that will only be released when calling [method@Clutter.Actor.remove_child]. This function will take into consideration the depth of @child, and will keep the list of children sorted. This function will emit the [signal@Clutter.Actor::child-added] signal on @self.

a #ClutterActor

Adds @constraint to the list`of `ClutterConstraint`s applied to @self The #ClutterActor will hold a reference on the @constraint until either [method@Clutter.Actor.remove_constraint] or [method@Clutter.Actor.clear_constraints] is called.

a #ClutterActor

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: ```c clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), name); clutter_actor_add_constraint (self, constraint); ```

a #ClutterActor

the name to set on the constraint a #ClutterConstraint

Adds @effect to the list of [class@Clutter.Effect]s applied to @self The #ClutterActor will hold a reference on the @effect until either [method@Clutter.Actor.remove_effect] or [method@Clutter.Actor.clear_effects] is called.

a #ClutterActor

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: ```c clutter_actor_meta_set_name (CLUTTER_ACTOR_META (effect), name); clutter_actor_add_effect (self, effect); ```

a #ClutterActor

the name to set on the effect a #ClutterEffect

Adds a @transition to the #ClutterActor's list of animations. The @name string is a per-actor unique identifier of the @transition: only one #ClutterTransition can be associated to the specified @name. The @transition will be started once added. This function will take a reference on the @transition. This function is usually called implicitly when modifying an animatable property.

a #ClutterActor

the name of the transition to add the #ClutterTransition to add

A #ClutterActor

new allocation of the actor, in parent-relative coordinates

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 [property@Clutter.Actor:request-mode] property, and the text direction. This function is useful for fluid layout managers using legacy alignment flags. Newly written layout managers should use the [property@Clutter.Actor:x-align] and [property@Clutter.Actor:y-align] properties, instead, and just call [method@Clutter.Actor.allocate] inside their [vfunc@Clutter.Actor.allocate] implementation.

a #ClutterActor

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

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: ```c if (request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH) { clutter_actor_get_preferred_width (self, available_height, &min_width, &natural_width); width = CLAMP (natural_width, min_width, available_width); clutter_actor_get_preferred_height (self, width, &min_height, &natural_height); height = CLAMP (natural_height, min_height, available_height); } else if (request_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT) { clutter_actor_get_preferred_height (self, available_width, &min_height, &natural_height); height = CLAMP (natural_height, min_height, available_height); clutter_actor_get_preferred_width (self, height, &min_width, &natural_width); width = CLAMP (natural_width, min_width, available_width); } else if (request_mode == CLUTTER_REQUEST_CONTENT_SIZE) { clutter_content_get_preferred_size (content, &natural_width, &natural_height); width = CLAMP (natural_width, 0, available_width); height = CLAMP (natural_height, 0, available_height); } box.x1 = x; box.y1 = y; box.x2 = box.x1 + available_width; box.y2 = box.y1 + available_height; clutter_actor_allocate (self, &box); ``` 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.

a #ClutterActor

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

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 [vfunc@Clutter.Actor.allocate] implementation to give each child exactly how much space it requires, regardless of the size of the parent. This function is not meant to be used by applications. It is also not meant to be used outside the implementation of the #ClutterActorClass.allocate virtual function.

a #ClutterActor

the actor's X coordinate the actor's Y coordinate

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

A #ClutterActor ancestor, or %NULL to use the default #ClutterStage A point as #graphene_point3d_t The translated #graphene_point3d_t

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

A #ClutterActor

A point as #graphene_point3d_t The translated #graphene_point3d_t

Binds a #GListModel to a #ClutterActor. If the #ClutterActor was already bound to a #GListModel, the previous binding is destroyed. The existing children of #ClutterActor are destroyed when setting a model, and new children are created and added, representing the contents of the @model. The #ClutterActor is updated whenever the @model changes. If @model is %NULL, the #ClutterActor is left empty. When a #ClutterActor is bound to a model, adding and removing children directly is undefined behaviour.4

a #ClutterActor

a #GListModel a function that creates #ClutterActor instances from the contents of the @model user data passed to @create_child_func function called when unsetting the @model

Binds a #GListModel to a #ClutterActor. Unlike clutter_actor_bind_model(), this function automatically creates a child #ClutterActor of type @child_type, and binds properties on the items inside the @model to the corresponding properties on the child, for instance: ```c clutter_actor_bind_model_with_properties (actor, model, MY_TYPE_CHILD_VIEW, "label", "text", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE, "icon", "image", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE, "selected", "selected", G_BINDING_BIDIRECTIONAL, "active", "active", G_BINDING_BIDIRECTIONAL, NULL); ``` is the equivalent of calling clutter_actor_bind_model() with a #ClutterActorCreateChildFunc of: ```c ClutterActor *res = g_object_new (MY_TYPE_CHILD_VIEW, NULL); g_object_bind_property (item, "label", res, "text", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); g_object_bind_property (item, "icon", res, "image", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); g_object_bind_property (item, "selected", res, "selected", G_BINDING_BIDIRECTIONAL); g_object_bind_property (item, "active", res, "active", G_BINDING_BIDIRECTIONAL); return res; ``` If the #ClutterActor was already bound to a #GListModel, the previous binding is destroyed. When a #ClutterActor is bound to a model, adding and removing children directly is undefined behaviour. See also: clutter_actor_bind_model()4

a #ClutterActor

a #GListModel the type of #ClutterActor to use when creating children mapping to items inside the @model the first property of @model to bind tuples of property names on the @model, on the child, and the #GBindingFlags used to bind them, terminated by %NULL

Clears the list of actions applied to @self

a #ClutterActor

Clears the list of constraints applied to @self

a #ClutterActor

Clears the list of effects applied to @self

a #ClutterActor

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

whether @descendent is contained within @self

A #ClutterActor

A #ClutterActor, possibly contained in @self

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

A #ClutterActor

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

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 [method@Clutter.Actor.get_pango_context].

the newly created #PangoContext. Use g_object_unref() on the returned value to deallocate its resources

a #ClutterActor

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.

the newly created #PangoLayout. Use g_object_unref() when done

a #ClutterActor

the text to set on the #PangoLayout, or %NULL

Creates a #ClutterPaintNode initialized using the state of the given #ClutterActor, ready to be used inside the implementation of the #ClutterActorClass.paint_node virtual function. The returned paint node has the geometry set to the size of the [property@Clutter.Actor:content-box] property; it uses the filters specified in the [property@Clutter.Actor:minification-filter] and [property@Clutter.Actor:magnification-filter] properties; and respects the [property@Clutter.Actor:content-repeat] property.

The newly created #ClutterPaintNode4

a #ClutterActor

a #CoglTexture

a #ClutterActor

Destroys all children of @self. This function releases the reference added by inserting a child actor in the list of children of @self, and ensures that the [signal@Clutter.Actor::destroy] signal is emitted on each child of the actor. By default, #ClutterActor will emit the [signal@Clutter.Actor::destroy] signal when its reference count drops to 0; the default handler of the [signal@Clutter.Actor::destroy] signal will destroy all the children of an actor. This function ensures that all children are destroyed, instead of just removed from @self, unlike [method@Clutter.Actor.remove_all_children] which will merely release the reference and remove each child. Unless you acquired an additional reference on each child of @self prior to calling [method@Clutter.Actor.remove_all_children] and want to reuse the actors, you should use [method@Clutter.Actor.destroy_all_children] in order to make sure that children are destroyed and signal handlers are disconnected even in cases where circular references prevent this from automatically happening through reference counting alone.

a #ClutterActor

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

the return value from the signal emission: %TRUE if the actor handled the event, or %FALSE if the event was not handled

a #ClutterActor

a #ClutterEvent %TRUE if event in in capture phase, %FALSE otherwise.

Calculates the transformed screen coordinates of the four corners of the actor; the returned vertices relate to the #ClutterActorBox coordinates as follows: - v[0] contains (x1, y1) - v[1] contains (x2, y1) - v[2] contains (x1, y2) - v[3] contains (x2, y2)

A #ClutterActor

Pointer to a location of an array of 4 #graphene_point3d_t where to store the result.

the #AtkObject associated with @actor

a #ClutterActor

Gets the accessible name for this widget. See clutter_actor_set_accessible_name() for more information.

a character string representing the accessible name of the widget.

widget to get the accessible name for

Gets the #AtkRole for this widget. See clutter_actor_set_accessible_role() for more information.

accessible #AtkRole for this widget

widget to get the accessible role for

Retrieves the #ClutterAction with the given name in the list of actions applied to @self

a #ClutterAction for the given name, or %NULL. The returned #ClutterAction is owned by the actor and it should not be unreferenced directly

a #ClutterActor

the name of the action to retrieve

Retrieves the list of actions applied to @self

a copy 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 #ClutterActor

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 translation; those transformations do not affect layout, only rendering. Do not call any of the clutter_actor_get_allocation_*() family of functions inside the implementation of the get_preferred_width() or get_preferred_height() virtual functions.

A #ClutterActor

the function fills this in with the actor's allocation

Retrieves the color set using [method@Clutter.Actor.set_background_color].

a #ClutterActor

return location for a #CoglColor

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

a pointer to a #ClutterActor, or %NULL

a #ClutterActor

the position in the list of children

Retrieves the child transformation matrix set using [method@Clutter.Actor.set_child_transform]; if none is currently set, the @transform matrix will be initialized to the identity matrix.

a #ClutterActor

a #graphene_matrix_t

Retrieves the list of children of @self.

A newly allocated #GList of `ClutterActor`s. Use g_list_free() when done.

a #ClutterActor

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

a #ClutterActor

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

Retrieves the value set using clutter_actor_set_clip_to_allocation()

%TRUE if the #ClutterActor is clipped to its allocation

a #ClutterActor

Retrieves the color_state of a [class@Actor] set by [method@Actor.set_color_state].

the #ClutterColorState

a #ClutterActor

Retrieves the #ClutterConstraint with the given name in the list of constraints applied to @self

a #ClutterConstraint for the given name, or %NULL. The returned #ClutterConstraint is owned by the actor and it should not be unreferenced directly

a #ClutterActor

the name of the constraint to retrieve

Retrieves the list of constraints applied to @self

a copy 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 #ClutterActor

Retrieves the contents of @self.

a pointer to the #ClutterContent instance, or %NULL if none was set

a #ClutterActor

Retrieves the bounding box for the #ClutterContent of @self. The bounding box is relative to the actor's allocation. If no #ClutterContent is set for @self, or if @self has not been allocated yet, then the result is undefined. The content box is guaranteed to be, at most, as big as the allocation of the #ClutterActor. If the #ClutterContent used by the actor has a preferred size, then it is possible to modify the content box by using the [property@Clutter.Actor:content-gravity] property.

a #ClutterActor

the return location for the bounding box for the #ClutterContent

Retrieves the content gravity as set using [method@Clutter.Actor.set_content_gravity].

the content gravity

a #ClutterActor

Retrieves the repeat policy for a #ClutterActor set by [method@Clutter.Actor.set_content_repeat].

the content repeat policy

a #ClutterActor

Retrieves the values set using [method@Clutter.Actor.set_content_scaling_filters].

a #ClutterActor

return location for the minification filter, or %NULL return location for the magnification filter, or %NULL

the Clutter context

a #ClutterActor

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

a delay, in milliseconds

a #ClutterActor

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

the duration of the tweening, in milliseconds

a #ClutterActor

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

an easing mode

a #ClutterActor

Retrieves the #ClutterEffect with the given name in the list of effects applied to @self

a #ClutterEffect for the given name, or %NULL. The returned #ClutterEffect is owned by the actor and it should not be unreferenced directly

a #ClutterActor

the name of the effect to retrieve

Retrieves the `ClutterEffect`s applied on @self, if any

a list 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 #ClutterActor

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

a pointer to a #ClutterActor, or %NULL

a #ClutterActor

This function gets the fixed position of the actor, if set. If there is no fixed position set, this function returns %FALSE and doesn't set the x and y coordinates.

%TRUE if the fixed position is set, %FALSE if it isn't

a #ClutterActor

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

A #ClutterActor

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 [method@Clutter.Actor.get_allocation_box] to retrieve the allocated size [method@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 [method@Clutter.Actor.set_height], the height returned will be the same value.

the height of the actor, in pixels

A #ClutterActor

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

a pointer to a #ClutterActor, or %NULL

a #ClutterActor

Retrieves the #ClutterLayoutManager used by @self.

a pointer to the #ClutterLayoutManager, or %NULL

a #ClutterActor

Retrieves all the components of the margin of a #ClutterActor.

a #ClutterActor

return location for a #ClutterMargin

Retrieves the bottom margin of a #ClutterActor.

the bottom margin

a #ClutterActor

Retrieves the left margin of a #ClutterActor.

the left margin

a #ClutterActor

Retrieves the right margin of a #ClutterActor.

the right margin

a #ClutterActor

Retrieves the top margin of a #ClutterActor.

the top margin

a #ClutterActor

Retrieves the number of children of @self.

the number of children of an actor

a #ClutterActor

Retrieves the name of @self.

the name of the actor, or %NULL. The returned string is owned by the actor and should not be modified or freed.

A #ClutterActor

Retrieves the sibling of @self that comes after it in the list of children of @self's parent. The returned pointer is only valid until the scene graph changes; it is not safe to modify the list of children of @self while iterating it.

a pointer to a #ClutterActor, or %NULL

a #ClutterActor

Retrieves whether to redirect the actor to an offscreen buffer, as set by clutter_actor_set_offscreen_redirect().

the value of the offscreen-redirect property of the actor

a #ClutterActor

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

a #ClutterActor

See clutter_actor_set_opacity_override()

the override value for the actor's opacity, or -1 if no override is set.2

a #ClutterActor

Retrieves the paint volume of the passed #ClutterActor, and transforms it into a 2D bounding box in stage coordinates. This function is useful to determine the on screen area occupied by the actor. The box is only an approximation and may often be considerably larger due to the optimizations used to calculate the box. The box is never smaller though, so it can reliably be used for culling. There are times when a 2D paint box can't be determined, e.g. because the actor isn't yet parented under a stage or because the actor is unable to determine a paint volume.

%TRUE if a 2D paint box could be determined, else %FALSE.

a #ClutterActor

return location for a #ClutterActorBox

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.

A #ClutterActor

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 visible and will be painted.

A #ClutterActor

Retrieves the paint volume of the passed #ClutterActor, or %NULL when a paint volume can't be determined. The paint volume is defined as the 3D space occupied by an actor when being painted. This function will call the [vfunc@Clutter.Actor.get_paint_volume] virtual function of the #ClutterActor class. Sub-classes of #ClutterActor should not usually care about overriding the default implementation, unless they are, for instance: painting outside their allocation, or actors with a depth factor (not in terms of depth but real 3D depth). Note: 2D actors overriding [vfunc@Clutter.Actor.get_paint_volume] should ensure that their volume has a depth of 0. (This will be true as long as you don't call [method@Clutter.PaintVolume.set_depth].)

a pointer to a #ClutterPaintVolume, or %NULL if no volume could be determined. The returned pointer is not guaranteed to be valid across multiple frames; if you want to keep it, you will need to copy it using [method@Clutter.PaintVolume.copy].

a #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 clutter_show_layout() to reuse the glyphs cache also used by Clutter.

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

a #ClutterActor

Retrieves the parent of @self.

The #ClutterActor parent, or %NULL if no parent is set

A #ClutterActor

Retrieves the coordinates of the [property@Clutter.Actor:pivot-point].

a #ClutterActor

return location for the normalized X coordinate of the pivot point, or %NULL return location for the normalized Y coordinate of the pivot point, or %NULL

Retrieves the Z component of the [property@Clutter.Actor:pivot-point].

a #ClutterActor

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.

a #ClutterActor

return location for the X coordinate, or %NULL return location for the Y coordinate, or %NULL

A #ClutterActor

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 [method@Clutter.Actor.get_preferred_width] and [method@Clutter.Actor.get_preferred_height], and check the actor's preferred geometry management using the [property@Clutter.Actor:request-mode] property.

a #ClutterActor

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

A #ClutterActor

Retrieves the sibling of @self that comes before it in the list of children of @self's parent. The returned pointer is only valid until the scene graph changes; it is not safe to modify the list of children of @self while iterating it.

a pointer to a #ClutterActor, or %NULL

a #ClutterActor

Checks whether @actor is marked as reactive.

%TRUE if the actor is reactive

a #ClutterActor

Retrieves the geometry request mode of @self

the request mode for the actor

a #ClutterActor

Retrieves the resource scale for this actor. The resource scale refers to the scale the actor should use for its resources. For example if an actor draws a a picture of size 100 x 100 in the stage coordinate space, it should use a texture of twice the size (i.e. 200 x 200) if the resource scale is 2. The resource scale is determined by calculating the highest #ClutterStageView scale the actor will get painted on. Note that the scale returned by this function is only guaranteed to be correct when queried during the paint cycle, in all other cases this function will only return a best guess. If your implementation really needs to get a resource scale outside of the paint cycle, make sure to subscribe to the "resource-scale-changed" signal to get notified about the new, correct resource scale before painting. Also avoid getting the resource scale for actors that are not attached to a stage. There's no sane way for Clutter to guess which #ClutterStageView the actor is going to be painted on, so you'll probably end up receiving the "resource-scale-changed" signal and having to rebuild your resources. The best guess this function may return is usually just the last resource scale the actor got painted with. If this resource scale couldn't be found because the actor was never painted so far or Clutter was unable to determine its position and size, this function will return the resource scale of a parent.

The resource scale the actor should use for its textures

A #ClutterActor

Retrieves the angle of rotation set by clutter_actor_set_rotation_angle().

the angle of rotation, in degrees

a #ClutterActor

the axis of the rotation

Retrieves an actors scale factors.

A #ClutterActor

Location to store horizontal scale factor, or %NULL. Location to store vertical scale factor, or %NULL.

Retrieves the scaling factor along the Z axis, as set using [method@Clutter.Actor.set_scale_z].

the scaling factor along the Z axis

A #ClutterActor

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 [method@Clutter.Actor.get_allocation_box] or [method@Clutter.Actor.get_preferred_width].

A #ClutterActor

return location for the width, or %NULL. return location for the height, or %NULL.

Retrieves the #ClutterStage where @actor is contained.

the stage containing the actor, or %NULL

a #ClutterActor

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

a #ClutterActor

Retrieves the current transformation matrix of a #ClutterActor.

a #ClutterActor

a #graphene_matrix_t

Gets the transformed bounding rect of an actor, in pixels relative to the stage. Using this outside of paint() may result in outdated results. The result can only be assumed valid inside a paint() method, or an allocate() function of an actor that explicitly gets allocated after @self; anywhere else, it may be out-of-date.

A #ClutterActor

return location for the transformed bounding rect

Retrieves the 3D paint volume of an actor like [method@Clutter.Actor.get_paint_volume] does and it additionally transforms the paint volume into the coordinate space of @relative_to_ancestor. (Or the stage if %NULL is passed for @relative_to_ancestor) This can be used by containers that base their paint volume on the volume of their children. Such containers can query the transformed paint volume of all of its children and union them together using [method@Clutter.PaintVolume.union].

a pointer to a #ClutterPaintVolume, or %NULL if no volume could be determined.

a #ClutterActor

A #ClutterActor that is an ancestor of @self (or %NULL for the stage)

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

A #ClutterActor

return location for the X coordinate, or %NULL return location for the Y coordinate, 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 [method@Clutter.Actor.get_abs_allocation_vertices] instead. When the actor (or one of its ancestors) is rotated around the X or Y axis, it no longer appears as on the stage as a rectangle, but as a generic quadrangle; in that case this function returns the size of the smallest rectangle that encapsulates the entire quad. Please note that in this case no assumptions can be made about the relative position of this envelope to the absolute position of the actor, as returned by [method@Clutter.Actor.get_transformed_position]; if you need this information, you need to use [method@Clutter.Actor.get_abs_allocation_vertices] to get the coords of the actual quadrangle.

A #ClutterActor

return location for the width, or %NULL return location for the height, or %NULL

Retrieves the #ClutterTransition of a #ClutterActor by using the transition @name. Transitions created for animatable properties use the name of the property itself, for instance the code below: ```c clutter_actor_set_easing_duration (actor, 1000); clutter_actor_set_rotation_angle (actor, CLUTTER_Y_AXIS, 360.0); transition = clutter_actor_get_transition (actor, "rotation-angle-y"); g_signal_connect (transition, "stopped", G_CALLBACK (on_transition_stopped), actor); ``` will call the `on_transition_stopped` callback when the transition is finished. If you just want to get notifications of the completion of a transition, you should use the [signal@Clutter.Actor::transition-stopped] signal, using the transition name as the signal detail.

a #ClutterTransition, or %NULL if none was found to match the passed name; the returned instance is owned by Clutter and it should not be freed

a #ClutterActor

the name of the transition

Retrieves the translation set using clutter_actor_set_translation().

a #ClutterActor

return location for the X component of the translation, or %NULL return location for the Y component of the translation, or %NULL return location for the Z component of the translation, or %NULL

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 [method@Clutter.Actor.get_allocation_box] to retrieve the allocated size [method@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 [method@Clutter.Actor.set_width], the width returned will be the same value.

the width of the actor, in pixels

A #ClutterActor

Retrieves the X coordinate of a #ClutterActor. This function tries to "do what you mean", by returning the correct value depending on the actor's state. If the actor has a valid allocation, this function will return the X coordinate of the origin of the allocation box. If the actor has any fixed coordinate set using [method@Clutter.Actor.set_x], [method@Clutter.Actor.set_position], this function will return that coordinate. If both the allocation and a fixed position are missing, this function will return 0.

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

A #ClutterActor

Retrieves the horizontal alignment policy set using [method@Clutter.Actor.set_x_align].

the horizontal alignment policy.

a #ClutterActor

Retrieves the value set with [method@Clutter.Actor.set_x_expand]. See also: [method@Clutter.Actor.needs_expand]

%TRUE if the actor has been set to expand

a #ClutterActor

Retrieves the Y coordinate of a #ClutterActor. This function tries to "do what you mean", by returning the correct value depending on the actor's state. If the actor has a valid allocation, this function will return the Y coordinate of the origin of the allocation box. If the actor has any fixed coordinate set using [method@Clutter.Actor.set_y], [method@Clutter.Actor.set_position], this function will return that coordinate. If both the allocation and a fixed position are missing, this function will return 0.

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

A #ClutterActor

Retrieves the vertical alignment policy set using [method@Clutter.Actor.set_y_align].

the vertical alignment policy.

a #ClutterActor

Retrieves the value set with [method@Clutter.Actor.set_y_expand]. See also: [method@Clutter.Actor.needs_expand]

%TRUE if the actor has been set to expand

a #ClutterActor

Retrieves the actor's position on the Z axis.

the position on the Z axis.

a #ClutterActor

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

a #ClutterActor

Returns whether the actor has any actions applied.

%TRUE if the actor has any actions, %FALSE otherwise

A #ClutterActor

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

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

a #ClutterActor

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

%TRUE if the actor has a clip area set.

a #ClutterActor

Returns whether the actor has any constraints applied.

%TRUE if the actor has any constraints, %FALSE otherwise

A #ClutterActor

Returns whether the actor has any effects applied.

%TRUE if the actor has any effects, %FALSE otherwise

A #ClutterActor

Checks whether @self is the #ClutterActor that has key focus

%TRUE if the actor has key focus, and %FALSE otherwise

a #ClutterActor

Returns whether a #ClutterActor or any parent actors have mapped clones that are clone-painting @self.

%TRUE if the actor has mapped clones, %FALSE otherwise

a #ClutterActor

%TRUE if the actor may have overlapping primitives, and %FALSE otherwise

A #ClutterActor

Checks whether an actor contains the pointer of a #ClutterInputDevice

%TRUE if the actor contains the pointer, and %FALSE otherwise

a #ClutterActor

A #ClutterActor

Increases the culling inhibitor counter. Inhibiting culling forces the actor to be painted even when outside the visible bounds of the stage view. This is usually necessary when an actor is being painted on another paint context. Pair with clutter_actor_uninhibit_culling() when the actor doesn't need to be painted anymore.

a #ClutterActor

Inserts @child into the list of children of @self, above another child of @self or, if @sibling is %NULL, above all the children of @self. This function will acquire a reference on @child that will only be released when calling [method@Clutter.Actor.remove_child]. This function will not take into consideration the depth of @child. This function will emit the [signal@Clutter.Actor::child-added] signal on @self.

a #ClutterActor

a #ClutterActor a child of @self, or %NULL

Inserts @child into the list of children of @self, using the given @index_. If @index_ is greater than the number of children in @self, or is less than 0, then the new child is added at the end. This function will acquire a reference on @child that will only be released when calling [method@Clutter.Actor.remove_child]. This function will not take into consideration the depth of @child. This function will emit the [signal@Clutter.Actor::child-added] signal on @self.

a #ClutterActor

a #ClutterActor the index

Inserts @child into the list of children of @self, below another child of @self or, if @sibling is %NULL, below all the children of @self. This function will acquire a reference on @child that will only be released when calling [method@Clutter.Actor.remove_child]. This function will not take into consideration the depth of @child. This function will emit the [signal@Clutter.Actor::child-added] signal on @self.

a #ClutterActor

a #ClutterActor a child of @self, or %NULL

Invalidates the cached paint volume of @self. This is needed for implementations overriding the [vfunc@Clutter.Actor.get_paint_volume] virtual function and has to be called every time the paint volume returned by that function would change.

A #ClutterActor

Invalidate the cached transformation matrix of @self. This is needed for implementations overriding the apply_transform() vfunc and has to be called if the matrix returned by apply_transform() would change.

A #ClutterActor

Checks whether @self is being currently painted by a #ClutterClone This function is useful only inside implementations of the [vfunc@Clutter.Actor.paint] virtual function. This function should not be used by applications

%TRUE if the #ClutterActor is currently being painted by a #ClutterClone, and %FALSE otherwise

a #ClutterActor

Checks whether a #ClutterActor has been set as mapped. See also [property@Clutter.Actor:mapped]

%TRUE if the actor is mapped4

a #ClutterActor

Checks whether @actor is marked as no layout. That means the @actor provides an explicit layout management policy for its children; this will prevent Clutter from automatic queueing of relayout and will defer all layouting to the actor itself

%TRUE if the actor is marked as no layout

a #ClutterActor

Checks whether a #ClutterActor is realized.

%TRUE if the actor is realized4

a #ClutterActor

Checks whether any rotation is applied to the actor.

%TRUE if the actor is rotated.

a #ClutterActor

Checks whether the actor is scaled in either dimension.

%TRUE if the actor is scaled.

a #ClutterActor

Checks whether an actor is marked as visible.

%TRUE if the actor visible4

a #ClutterActor

A #ClutterActor

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

A #ClutterActor

Distance to move Actor on X axis. Distance to move Actor on Y axis.

Checks whether an actor, or any of its children, is set to expand horizontally or vertically. This function should only be called by layout managers that can assign extra space to their children. If you want to know whether the actor was explicitly set to expand, use [method@Clutter.Actor.get_x_expand] or [method@Clutter.Actor.get_y_expand].

%TRUE if the actor should expand

a #ClutterActor

the direction of expansion

A #ClutterActor

Retrieves the list of `ClutterStageView`s the actor is being painted on. If this function is called during the paint cycle, the list is guaranteed to be up-to-date, if called outside the paint cycle, the list will contain the views the actor was painted on last. The list returned by this function is not updated when the actors visibility changes: If an actor gets hidden and is not being painted anymore, this function will return the list of views the actor was painted on last. If an actor is not attached to a stage (realized), this function will always return an empty list.

The list of `ClutterStageView`s the actor is being painted on. The list and its contents are owned by the #ClutterActor and the list may not be freed or modified.

A #ClutterActor

Asks @actor to perform a pick.

A #ClutterActor

Logs (does a virtual paint of) a rectangle for picking. Note that @box is in the actor's own local coordinates, so is usually {0,0,width,height} to include the whole actor. That is unless the actor has a shaped input region in which case you may wish to log the (multiple) smaller rectangles that make up the input region.

The #ClutterActor being "pick" painted.

The #ClutterPickContext A rectangle in the actor's own local coordinates.

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.

A #ClutterActor

Queues a redraw on @self limited to a specific, actor-relative rectangular area. If @clip is %NULL this function is equivalent to clutter_actor_queue_redraw().

a #ClutterActor

a rectangular clip region, or %NULL

A #ClutterActor

Actors are automatically realized, and nothing requires explicit realization.

A #ClutterActor

This method removes @state as on of the accessible states for @actor. See [method@Clutter.Actor.add_accessible_state] for more information.

A #ClutterActor

#AtkState state to remove

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

a #ClutterActor

a #ClutterAction

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

a #ClutterActor

the name of the action to remove

Removes all children of @self. This function releases the reference added by inserting a child actor in the list of children of @self. If the reference count of a child drops to zero, the child will be destroyed. If you want to ensure the destruction of all the children of @self, use clutter_actor_destroy_all_children().

a #ClutterActor

Removes all transitions associated to @self.

a #ClutterActor

Removes @child from the children of @self. This function will release the reference added by [method@Clutter.Actor.add_child], so if you want to keep using @child you will have to acquire a referenced on it before calling this function. This function will emit the [signal@Clutter.Actor::child-removed] signal on @self.

a #ClutterActor

Removes clip area from @self.

A #ClutterActor

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

a #ClutterActor

a #ClutterConstraint

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

a #ClutterActor

the name of the constraint to remove

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

a #ClutterActor

a #ClutterEffect

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

a #ClutterActor

the name of the effect to remove

Removes the transition stored inside a #ClutterActor using @name identifier. If the transition is currently in progress, it will be stopped. This function releases the reference acquired when the transition was added to the #ClutterActor.

a #ClutterActor

the name of the transition to remove

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

a #ClutterActor

the child of @self to replace the #ClutterActor to replace @old_child

Restores the easing state as it was prior to a call to [method@Clutter.Actor.save_easing_state].

a #ClutterActor

Saves the current easing state for animatable properties, and creates a new state with the default values for easing mode and duration. New transitions created after calling this function will inherit the duration, easing mode, and delay of the new easing state; this also applies to transitions modified in flight.

a #ClutterActor

This method allows to set a customly created accessible object to this widget NULL is a valid value for @accessible. That contemplates the hypothetical case of not needing anymore a custom accessible object for the widget. Next call of [method@Clutter.Actor.get_accessible] would create and return a default accessible. It assumes that the call to atk_object_initialize that bound the gobject with the custom accessible object was already called, so not a responsibility of this method.

A #ClutterActor

an accessible

This method sets @name as the accessible name for @self. Usually you will have no need to set the accessible name for an object, as usually there is a label for most of the interface elements.

widget to set the accessible name for

a character string to be set as the accessible name

This method sets @role as the accessible role for @self. This role describes what kind of user interface element @self is and is provided so that assistive technologies know how to present @self to the user. Usually you will have no need to set the accessible role for an object, as this information is extracted from the context of the object (ie: a #StButton has by default a push button role). This method is only required when you need to redefine the role currently associated with the widget, for instance if it is being used in an unusual way (ie: a #StButton used as a togglebutton), or if a generic object is used directly (ie: a container as a menu item). If @role is #ATK_ROLE_INVALID, the role will not be changed and the accessible's default role will be used instead.

widget to set the accessible role for

The role to use

Stores the allocation of @self as defined by @box. This function can only be called from within the implementation of the [vfunc@Clutter.Actor.allocate] virtual function. The allocation @box should have been adjusted to take into account constraints, alignment, and margin properties. This function should only be used by subclasses of #ClutterActor that wish to store their allocation but cannot chain up to the parent's implementation; the default implementation of the [vfunc@Clutter.Actor.allocate] virtual function will call this function.

a #ClutterActor

a #ClutterActorBox

Sets the background color of a #ClutterActor. The background color will be used to cover the whole allocation of the actor. The default background color of an actor is transparent. To check whether an actor has a background color, you can use the [property@Clutter.Actor:background-color-set] actor property. The [property@Clutter.Actor:background-color] property is animatable.

a #ClutterActor

a #CoglColor, or %NULL to unset a previously set color

Sets @child to be above @sibling in the list of children of @self. If @sibling is %NULL, @child will be the new last child of @self. This function is logically equivalent to removing @child and using clutter_actor_insert_child_above(), but it will not emit signals or change state on @child.

a #ClutterActor

a #ClutterActor child of @self a #ClutterActor child of @self, or %NULL

Changes the index of @child in the list of children of @self. This function is logically equivalent to removing @child and calling clutter_actor_insert_child_at_index(), but it will not emit signals or change state on @child.

a #ClutterActor

a #ClutterActor child of @self the new index for @child

Sets @child to be below @sibling in the list of children of @self. If @sibling is %NULL, @child will be the new first child of @self. This function is logically equivalent to removing @self and using clutter_actor_insert_child_below(), but it will not emit signals or change state on @child.

a #ClutterActor

a #ClutterActor child of @self a #ClutterActor child of @self, or %NULL

Sets the transformation matrix to be applied to all the children of @self prior to their own transformations. The default child transformation is the identity matrix. If @transform is %NULL, the child transform will be unset. The [property@Clutter.Actor:child-transform] property is animatable.

a #ClutterActor

a #graphene_matrix_t, or %NULL

Sets clip area for @self. The clip area is always computed from the upper left corner of the actor.

A #ClutterActor

X offset of the clip rectangle Y offset of the clip rectangle Width of the clip rectangle Height of the clip rectangle

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

a #ClutterActor

%TRUE to apply a clip tracking the allocation

Set @self's color state to @color_state.

a #ClutterActor

a #ClutterColorState

Sets the contents of a #ClutterActor.

a #ClutterActor

a #ClutterContent, or %NULL

Sets the gravity of the #ClutterContent used by @self. See the description of the [property@Clutter.Actor:content-gravity] property for more information. The [property@Clutter.Actor:content-gravity] property is animatable.

a #ClutterActor

the #ClutterContentGravity

Sets the policy for repeating the [property@Clutter.Actor:content] of a #ClutterActor. The behaviour is deferred to the #ClutterContent implementation.

a #ClutterActor

the repeat policy

Sets the minification and magnification filter to be applied when scaling the [property@Clutter.Actor:content] of a #ClutterActor. The [property@Clutter.Actor:minification-filter] will be used when reducing the size of the content; the [property@Clutter.Actor:magnification-filter] will be used when increasing the size of the content.

a #ClutterActor

the minification filter for the content the magnification filter for the content

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

a #ClutterActor

the delay before the start of the tweening, in milliseconds

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

a #ClutterActor

the duration of the easing, or %NULL

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

a #ClutterActor

an easing mode, excluding %CLUTTER_CUSTOM_MODE

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

A #ClutterActor

whether to use fixed position

Forces a height on an actor, causing the actor's preferred width and height (if any) to be ignored. If @height is -1 the actor will use its preferred height instead of overriding it, i.e. you can "unset" the height with -1. This function sets both the minimum and natural size of the actor.

A #ClutterActor

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

Sets the #ClutterLayoutManager delegate object that will be used to lay out the children of @self. The #ClutterActor will take a reference on the passed @manager which will be released either when the layout manager is removed, or when the actor is destroyed.

a #ClutterActor

a #ClutterLayoutManager, or %NULL to unset it

Sets all the components of the margin of a #ClutterActor.

a #ClutterActor

a #ClutterMargin

Sets the margin from the bottom of a #ClutterActor. The [property@Clutter.Actor:margin-bottom] property is animatable.

a #ClutterActor

the bottom margin

Sets the margin from the left of a #ClutterActor. The [property@Clutter.Actor:margin-left] property is animatable.

a #ClutterActor

the left margin

Sets the margin from the right of a #ClutterActor. The [property@Clutter.Actor:margin-right] property is animatable.

a #ClutterActor

the right margin

Sets the margin from the top of a #ClutterActor. The [property@Clutter.Actor:margin-top] property is animatable.

a #ClutterActor

the top margin

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

A #ClutterActor

Textual tag to apply to actor

Defines the circumstances where the actor should be redirected into an offscreen image. The offscreen image is used to flatten the actor into a single image while painting for two main reasons. Firstly, when the actor is painted a second time without any of its contents changing it can simply repaint the cached image without descending further down the actor hierarchy. Secondly, it will make the opacity look correct even if there are overlapping primitives in the actor. Caching the actor could in some cases be a performance win and in some cases be a performance lose so it is important to determine which value is right for an actor before modifying this value. For example, there is never any reason to flatten an actor that is just a single texture (such as a #ClutterTexture) because it is effectively already cached in an image so the offscreen would be redundant. Also if the actor contains primitives that are far apart with a large transparent area in the middle (such as a large CluterGroup with a small actor in the top left and a small actor in the bottom right) then the cached image will contain the entire image of the large area and the paint will waste time blending all of the transparent pixels in the middle. The default method of implementing opacity on a container simply forwards on the opacity to all of the children. If the children are overlapping then it will appear as if they are two separate glassy objects and there will be a break in the color where they overlap. By redirecting to an offscreen buffer it will be as if the two opaque objects are combined into one and then made transparent which is usually what is expected. The image below demonstrates the difference between redirecting and not. The image shows two Clutter groups, each containing a red and a green rectangle which overlap. The opacity on the group is set to 128 (which is 50%). When the offscreen redirect is not used, the red rectangle can be seen through the blue rectangle as if the two rectangles were separately transparent. When the redirect is used the group as a whole is transparent instead so the red rectangle is not visible where they overlap. <figure id="offscreen-redirect"> <title>Sample of using an offscreen redirect for transparency</title> <graphic fileref="offscreen-redirect.png" format="PNG"/> </figure> The default value for this property is 0, so we effectively will never redirect an actor offscreen by default. This means that there are times that transparent actors may look glassy as described above. The reason this is the default is because there is a performance trade off between quality and performance here. In many cases the default form of glassy opacity looks good enough, but if it's not you will need to set the %CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY flag to enable redirection for opacity. Custom actors that don't contain any overlapping primitives are recommended to override the has_overlaps() virtual to return %FALSE for maximum efficiency.

A #ClutterActor

New offscreen redirect flags for the actor.

Sets the actor's opacity, with zero being completely transparent and 255 (0xff) being fully opaque. The [property@Clutter.Actor:opacity] property is animatable.

A #ClutterActor

New opacity value for the actor.

Allows overriding the calculated paint opacity (as returned by clutter_actor_get_paint_opacity()). This is used internally by ClutterClone and ClutterOffscreenEffect, and should be used by actors that need to mimic those. In almost all cases this should not used by applications.

a #ClutterActor

the override opacity value, or -1 to reset

Sets the position of the [property@Clutter.Actor:pivot-point] around which the scaling and rotation transformations occur. The pivot point's coordinates are in normalized space, with the (0, 0) point being the top left corner of the actor, and the (1, 1) point being the bottom right corner.

a #ClutterActor

the normalized X coordinate of the pivot point the normalized Y coordinate of the pivot point

Sets the component on the Z axis of the [property@Clutter.Actor:pivot-point] around which the scaling and rotation transformations occur. The @pivot_z value is expressed as a distance along the Z axis.

a #ClutterActor

the Z coordinate of the actor's pivot point

Sets the actor's fixed position in pixels relative to any parent actor. If a layout manager is in use, this position will override the layout manager and force a fixed position.

A #ClutterActor

New left position of actor in pixels. New top position of actor in pixels.

Sets @actor as reactive. Reactive actors will receive events.

a #ClutterActor

whether the actor should be reactive to events

Sets the geometry request mode of @self. The @mode determines the order for invoking [method@Clutter.Actor.get_preferred_width] and [method@Clutter.Actor.get_preferred_height]

a #ClutterActor

the request mode

Sets the @angle of rotation of a #ClutterActor on the given @axis. This function is a convenience for setting the rotation properties [property@Clutter.Actor:rotation-angle-x], [property@Clutter.Actor:rotation-angle-y], and [property@Clutter.Actor:rotation-angle-z]. The center of rotation is established by the [property@Clutter.Actor:pivot-point] property.

a #ClutterActor

the axis to set the angle one the angle of rotation, in degrees

Scales an actor with the given factors. The scale transformation is relative the [property@Clutter.Actor:pivot-point]. The [property@Clutter.Actor:scale-x] and [property@Clutter.Actor:scale-y] properties are animatable.

A #ClutterActor

double factor to scale actor by horizontally. double factor to scale actor by vertically.

Scales an actor on the Z axis by the given @scale_z factor. The scale transformation is relative the the [property@Clutter.Actor:pivot-point]. The [property@Clutter.Actor:scale-z] property is animatable.

a #ClutterActor

the scaling factor along the Z axis

Sets the actor's size request in pixels. This overrides any "normal" size request the actor would have. For example a text actor might normally request the size of the text; this function would force a specific size instead. If @width and/or @height are -1 the actor will use its "normal" size request instead of overriding it, i.e. you can "unset" the size with -1. This function sets or unsets both the minimum and natural size.

A #ClutterActor

New width of actor in pixels, or -1 New height of actor in pixels, or -1

Sets the #ClutterTextDirection for an actor The passed text direction must not be %CLUTTER_TEXT_DIRECTION_DEFAULT This function will recurse inside all the children of @self

a #ClutterActor

the text direction for @self

Overrides the transformations of a #ClutterActor with a custom matrix, which will be applied relative to the origin of the actor's allocation and to the actor's pivot point. The [property@Clutter.Actor:transform] property is animatable.

a #ClutterActor

a #graphene_matrix_t, or %NULL to unset a custom transformation

Sets an additional translation transformation on a #ClutterActor, relative to the [property@Clutter.Actor:pivot-point].

a #ClutterActor

the translation along the X axis the translation along the Y axis the translation along the Z axis

Forces a width on an actor, causing the actor's preferred width and height (if any) to be ignored. If @width is -1 the actor will use its preferred width request instead of overriding it, i.e. you can "unset" the width with -1. This function sets both the minimum and natural size of the actor.

A #ClutterActor

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

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 [property@Clutter.Actor:x] property is animatable.

a #ClutterActor

the actor's position on the X axis

Sets the horizontal alignment policy of a #ClutterActor, in case the actor received extra horizontal space. See also the [property@Clutter.Actor:x-align] property.

a #ClutterActor

the horizontal alignment policy

Sets whether a #ClutterActor should expand horizontally; this means that layout manager should allocate extra space for the actor, if possible. Setting an actor to expand will also make all its parent expand, so that it's possible to build an actor tree and only set this flag on its leaves and not on every single actor.

a #ClutterActor

whether the actor should expand horizontally

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 [property@Clutter.Actor:y] property is animatable.

a #ClutterActor

the actor's position on the Y axis

Sets the vertical alignment policy of a #ClutterActor, in case the actor received extra vertical space. See also the [property@Clutter.Actor:y-align] property.

a #ClutterActor

the vertical alignment policy

a #ClutterActor

whether the actor should expand vertically

Sets the actor's position on the Z axis. See [property@Clutter.Actor:z-position].

a #ClutterActor

the position on the Z axis

Should be called inside the implementation of the [vfunc@Clutter.Actor.pick] virtual function in order to check whether the actor should be picked or not. This function should never be called directly by applications.

%TRUE if the actor should be picked, %FALSE otherwise

A #ClutterActor

a #ClutterPickContext

A #ClutterActor

This function translates screen coordinates (@x, @y) to coordinates relative to the actor. For example, it can be used to translate screen events from global screen coordinates into actor-local coordinates. The conversion can fail, notably if the transform stack results in the actor being projected on the screen as a mere line. The conversion should not be expected to be pixel-perfect due to the nature of the operation. In general the error grows when the skewing of the actor rectangle on screen increases. This function can be computationally intensive. This function only works when the allocation is up-to-date, i.e. inside of the [vfunc@Clutter.Actor.paint] implementation

%TRUE if conversion was successful.

A #ClutterActor

x screen coordinate of the point to unproject y screen coordinate of the point to unproject return location for the unprojected x coordinance return location for the unprojected y coordinance

Decreases the culling inhibitor counter. See clutter_actor_inhibit_culling() for when inhibit culling is necessary. Calling this function without a matching call to clutter_actor_inhibit_culling() is a programming error.

a #ClutterActor

A #ClutterActor

Actors are automatically unrealized, and nothing requires explicit realization.

A #ClutterActor

Set @self's color state to the default.

a #ClutterActor

Object instance's name for assistive technology access. The accessible role of this object 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 Paints a solid fill of the actor's allocation using the specified color. The [property@Clutter.Actor:background-color] property is animatable. Whether the [property@Clutter.Actor:background-color] property has been set. Applies a transformation matrix on each child of an actor. Setting this property with a #graphene_matrix_t will set the [property@Clutter.Actor:child-transform-set] property to %TRUE as a side effect; setting this property with %NULL will set the [property@Clutter.Actor:child-transform-set] property to %FALSE. The [property@Clutter.Actor:child-transform] property is animatable. Whether the [property@Clutter.Actor:child-transform] property is set. The visible region of the actor, in actor-relative coordinates, expressed as a #graphene_rect_t. Setting this property to %NULL will unset the existing clip. Setting this property will change the [property@Clutter.Actor:has-clip] property as a side effect. 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(). The #ClutterColorState contains the properties like colorspace for each actors. Adds a #ClutterConstraint to the actor The #ClutterContent implementation that controls the content of the actor. The bounding box for the #ClutterContent used by the actor. The value of this property is controlled by the [property@Clutter.Actor:allocation] and [property@Clutter.Actor:content-gravity] properties of #ClutterActor. The bounding box for the content is guaranteed to never exceed the allocation's of the actor. The alignment that should be honoured by the #ClutterContent set with the [property@Clutter.Actor:content] property. Changing the value of this property will change the bounding box of the content; you can use the [property@Clutter.Actor:content-box] property to get the position and size of the content within the actor's allocation. This property is meaningful only for #ClutterContent implementations that have a preferred size, and if the preferred size is smaller than the actor's allocation. The [property@Clutter.Actor:content-gravity] property is animatable. The repeat policy for the actor's [property@Clutter.Actor:content]. The %ClutterContext of the actor Adds #ClutterEffect to the list of effects be applied on a #ClutterActor The actor's first child. This flag controls whether the [property@Clutter.Actor:fixed-x] and [property@Clutter.Actor:fixed-y] properties are used The fixed X position of the actor in pixels. Writing this property sets [property@Clutter.Actor:fixed-position-set] property as well, as a side effect The fixed Y position of the actor in pixels. Writing this property sets the [property@Clutter.Actor:fixed-position-set] property as well, as a side effect Whether the actor has the [property@Clutter.Actor:clip-rect] 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. The [property@Clutter.Actor:height] property is animatable. The actor's last child. A delegate object for controlling the layout of the children of an actor. Whether the actor is mapped (will be painted when the stage to which it belongs is mapped) The margin (in pixels) from the bottom of the actor. This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor. The [property@Clutter.Actor:margin-bottom] property is animatable. The margin (in pixels) from the left of the actor. This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor. The [property@Clutter.Actor:margin-left] property is animatable. The margin (in pixels) from the right of the actor. This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor. The [property@Clutter.Actor:margin-right] property is animatable. The margin (in pixels) from the top of the actor. This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor. The [property@Clutter.Actor:margin-top] property is animatable. A forced minimum height request for the actor, in pixels Writing this property sets the [property@Clutter.Actor: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 [property@Clutter.Actor:min-height] property is used A forced minimum width request for the actor, in pixels Writing this property sets the [property@Clutter.Actor: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 [property@Clutter.Actor: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 [property@Clutter.Actor: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 [property@Clutter.Actor:natural-height] property is used A forced natural width request for the actor, in pixels Writing this property sets the [property@Clutter.Actor: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 [property@Clutter.Actor:natural-width] property is used Determines the conditions in which the actor will be redirected to an offscreen framebuffer while being painted. For example this can be used to cache an actor in a framebuffer or for improved handling of transparent actors. See clutter_actor_set_offscreen_redirect() for details. Opacity of an actor, between 0 (fully transparent) and 255 (fully opaque) The [property@Clutter.Actor:opacity] property is animatable. The point around which the scaling and rotation transformations occur. The pivot point is expressed in normalized coordinates space, with (0, 0) being the top left corner of the actor and (1, 1) the bottom right corner of the actor. The default pivot point is located at (0, 0). The [property@Clutter.Actor:pivot-point] property is animatable. The Z component of the [property@Clutter.Actor:pivot-point], expressed as a value along the Z axis. The [property@Clutter.Actor:pivot-point-z] property is animatable. The position of the origin of the actor. This property is a shorthand for setting and getting the [property@Clutter.Actor:x] and [property@Clutter.Actor:y] properties at the same time. The [property@Clutter.Actor:position] property is animatable. 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: ```c ClutterRequestMode mode; gfloat natural_width, min_width; gfloat natural_height, min_height; mode = clutter_actor_get_request_mode (child); if (mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH) { clutter_actor_get_preferred_width (child, -1, &min_width, &natural_width); clutter_actor_get_preferred_height (child, natural_width, &min_height, &natural_height); } else if (mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT) { clutter_actor_get_preferred_height (child, -1, &min_height, &natural_height); clutter_actor_get_preferred_width (child, natural_height, &min_width, &natural_width); } else if (mode == CLUTTER_REQUEST_CONTENT_SIZE) { ClutterContent *content = clutter_actor_get_content (child); min_width, min_height = 0; natural_width = natural_height = 0; if (content != NULL) clutter_content_get_preferred_size (content, &natural_width, &natural_height); } ``` will retrieve the minimum and natural width and height depending on the preferred request mode of the #ClutterActor "child". The [method@Clutter.Actor.get_preferred_size] function will implement this check for you. The rotation angle on the X axis. The [property@Clutter.Actor:rotation-angle-x] property is animatable. The rotation angle on the Y axis The [property@Clutter.Actor:rotation-angle-y] property is animatable. The rotation angle on the Z axis The [property@Clutter.Actor:rotation-angle-z] property is animatable. The horizontal scale of the actor. The [property@Clutter.Actor:scale-x] property is animatable. The vertical scale of the actor. The [property@Clutter.Actor:scale-y] property is animatable. The scale factor of the actor along the Z axis. The [property@Clutter.Actor:scale-y] property is animatable. 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. The size of the actor. This property is a shorthand for setting and getting the [property@Clutter.Actor:width] and [property@Clutter.Actor:height] at the same time. The [property@Clutter.Actor:size] property is animatable. The direction of the text inside a #ClutterActor. Overrides the transformations of a #ClutterActor with a custom matrix. The matrix specified by the [property@Clutter.Actor:transform] property is applied to the actor and its children relative to the actor's [property@Clutter.Actor:allocation] and [property@Clutter.Actor:pivot-point]. Application code should rarely need to use this function directly. Setting this property with a #graphene_matrix_t will set the [property@Clutter.Actor:transform-set] property to %TRUE as a side effect; setting this property with %NULL will set the [property@Clutter.Actor:transform-set] property to %FALSE. The [property@Clutter.Actor:transform] property is animatable. Whether the [property@Clutter.Actor:transform] property is set. An additional translation applied along the X axis, relative to the actor's [property@Clutter.Actor:pivot-point]. The [property@Clutter.Actor:translation-x] property is animatable. An additional translation applied along the Y axis, relative to the actor's [property@Clutter.Actor:pivot-point]. The [property@Clutter.Actor:translation-y] property is animatable. An additional translation applied along the Z axis, relative to the actor's [property@Clutter.Actor:pivot-point]. The [property@Clutter.Actor:translation-z] property is animatable. Whether the actor is set to be visible or not See also [property@Clutter.Actor: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. The [property@Clutter.Actor:width] property is animatable. X coordinate of the actor in pixels. If written, forces a fixed position for the actor. If read, returns the fixed position if any, otherwise the allocation if available, otherwise 0. The [property@Clutter.Actor:x] property is animatable. The alignment of an actor on the X axis, if the actor has been given extra space for its allocation. See also the [property@Clutter.Actor:x-expand] property. Whether a layout manager should assign more space to the actor on the X axis. 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 [property@Clutter.Actor:y] property is animatable. The alignment of an actor on the Y axis, if the actor has been given extra space for its allocation. Whether a layout manager should assign more space to the actor on the Y axis. The actor's position on the Z axis, relative to the parent's transformations. Positive values will bring the actor's position nearer to the user, whereas negative values will bring the actor's position farther from the user. The [property@Clutter.Actor:z-position] does not affect the paint or allocation order. The [property@Clutter.Actor:z-position] property is animatable. The signal is emitted each time a mouse button is pressed on @actor.

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a button [struct@Event] The signal is emitted each time a mouse button is released on @actor.

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a button [struct@Event] The signal is emitted when an event is captured by Clutter. This signal will be emitted starting from the top-level container (the [class@Clutter.Stage]) 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 [signal@Clutter.Actor::button-press-event] or [signal@Clutter.Actor::button-release-event]) are emitted.

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a #ClutterEvent The signal is emitted each time an actor has been added to @actor.

the new child that has been added to @actor The signal is emitted each time an actor is removed from @actor.

the child that has been removed from @actor

The signal notifies that all references held on the actor which emitted it should be released. The signal should be used by all holders of a reference on @actor. This signal might result in the finalization of the #ClutterActor if all references are released. Composite actors should override the default implementation of the class handler of this signal and call clutter_actor_destroy() on their children. When overriding the default class handler, it is required to chain up to the parent's implementation.

The signal is emitted when the pointer enters the @actor

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a crossing [struct@Event] The 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).

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a #ClutterEvent The signal is emitted when an actor is no longer rendered on the stage.

The signal is emitted when @actor receives key focus.

The signal is emitted when @actor loses key focus.

The signal is emitted each time a keyboard button is pressed while @actor has key focus (see clutter_stage_set_key_focus()).

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a key [struct@Event] The signal is emitted each time a keyboard button is released while @actor has key focus (see clutter_stage_set_key_focus()).

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a key [struct@Event] The signal is emitted when the pointer leaves the @actor.

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a crossing [struct@Event] The signal is emitted each time the mouse pointer is moved over @actor.

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a motion [struct@Event] This signal is emitted when the parent of the actor changes.

the previous parent of the actor, or %NULL The 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 [method@Clutter.Stage.get_actor_at_pos]. Subclasses of #ClutterActor should override the class signal handler and paint themselves in that function. It is possible to connect a handler to the signal in order to set up some custom aspect of a paint in pick mode.

Override the [vfunc@Clutter.Actor.pick] virtual function instead.

a #ClutterPickContext The signal is emitted when clutter_actor_queue_relayout() is called on an actor. The default implementation for #ClutterActor chains up to the parent actor and queues a relayout on the parent, thus "bubbling" the relayout queue up through the actor graph. The main purpose of this signal is to allow relayout to be propagated properly in the procense of #ClutterClone actors. Applications will not normally need to connect to this signal.

The signal is emitted each time an actor is being realized.

The signal should not be used in newly written code

The signal is emitted when the resource scale value returned by [method@Clutter.Actor.get_resource_scale] changes. This signal can be used to get notified about the correct resource scale when the scale had to be queried outside of the paint cycle.

The signal is emitted each time the mouse is scrolled on @actor

%TRUE if the event has been handled by the actor, or %FALSE to continue the emission.

a scroll [struct@Event] The signal is emitted when an actor is visible and rendered on the stage.

The signal is emitted when the position or size an actor is being painted at have changed so that it's visible on different stage views. This signal is also emitted when the actor gets detached from the stage or when the views of the stage have been invalidated and will be replaced; it's not emitted when the actor gets hidden.

The signal is emitted each time a touch begin/end/update/cancel event.

%CLUTTER_EVENT_STOP if the event has been handled by the actor, or %CLUTTER_EVENT_PROPAGATE to continue the emission.

a #ClutterEvent The signal is emitted once a transition is stopped; a transition is stopped once it reached its total duration (including eventual repeats), it has been stopped using [method@Clutter.Timeline.stop], or it has been removed from the transitions applied on @actor, using [method@Clutter.Actor.remove_transition].

the name of the transition whether the transition was finished, or stopped The signal is emitted once all transitions involving @actor are complete.

The signal is emitted each time an actor is being unrealized.

The signal should not be used in newly written code

Implementation of the ATK interfaces for [class@Clutter.Actor] #ClutterActorAccessible implements the required ATK interfaces of [class@Clutter.Actor] exposing the common elements on each actor (position, extents, etc).

Controls how a #ClutterActor should align itself inside the extra space assigned to it during the allocation. Alignment only matters if the allocated space given to an actor is bigger than its natural size; for example, when the [property@Clutter.Actor:x-expand] or the [property@Clutter.Actor:y-expand] properties of #ClutterActor are set to %TRUE. Stretch to cover the whole allocated space Snap to left or top side, leaving space to the right or bottom. For horizontal layouts, in right-to-left locales this should be reversed. Center the actor inside the allocation Snap to right or bottom side, leaving space to the left or top. For horizontal layouts, in right-to-left locales this should be reversed. 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

X coordinate of the top left corner Y coordinate of the top left corner X coordinate of the bottom right corner Y coordinate of the bottom right corner Allocates a new [struct@ActorBox] using the passed coordinates for the top left and bottom right points. This function is the logical equivalent of: ```c clutter_actor_box_init (clutter_actor_box_alloc (), x_1, y_1, x_2, y_2); ```

the newly allocated #ClutterActorBox. Use [method@ActorBox.free] to free the resources

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

Checks whether a point with @x, @y coordinates is contained within @box

%TRUE if the point is contained by the #ClutterActorBox

a #ClutterActorBox

X coordinate of the point Y coordinate of the point

Copies @box

a newly allocated copy of #ClutterActorBox. Use [method@ActorBox.free] to free the allocated resources

a #ClutterActorBox

Checks @box_a and @box_b for equality

%TRUE if the passed #ClutterActorBox are equal

a #ClutterActorBox

Frees a #ClutterActorBox allocated using [ctor@ActorBox.new] or [method@ActorBox.copy].

a #ClutterActorBox

Calculates the bounding box represented by the four vertices; for details of the vertex array see [method@Actor.get_abs_allocation_vertices].

a #ClutterActorBox

array of four #graphene_point3d_t

Retrieves the area of @box

the area of a #ClutterActorBox, in pixels

a #ClutterActorBox

Retrieves the height of the @box

the height of the box

a #ClutterActorBox

Retrieves the origin of @box

a #ClutterActorBox

return location for the X coordinate, or %NULL return location for the Y coordinate, or %NULL

Retrieves the size of @box

a #ClutterActorBox

return location for the width, or %NULL return location for the height, or %NULL

Retrieves the width of the @box

the width of the box

a #ClutterActorBox

Retrieves the X coordinate of the origin of @box

the X coordinate of the origin

a #ClutterActorBox

Retrieves the Y coordinate of the origin of @box

the Y coordinate of the origin

a #ClutterActorBox

Initializes @box with the given coordinates.

the initialized #ClutterActorBox

a #ClutterActorBox

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

Initializes @box with the given origin and size.

a #ClutterActorBox

X coordinate of the origin Y coordinate of the origin width of the box height of the box

Interpolates between @initial and @final `ClutterActorBox`es using @progress

the initial #ClutterActorBox

the final #ClutterActorBox the interpolation progress return location for the interpolation

Checks if @box has been initialized, a #ClutterActorBox is uninitialized if it has a size of -1 at an origin of 0, 0.

%TRUE if the box is uninitialized, %FALSE if it isn't

a #ClutterActorBox

Rescale the @box by provided @scale factor.

a #ClutterActorBox

scale factor for resizing this box

Changes the origin of @box, maintaining the size of the #ClutterActorBox.

a #ClutterActorBox

the X coordinate of the new origin the Y coordinate of the new origin

Sets the size of @box, maintaining the origin of the #ClutterActorBox.

a #ClutterActorBox

the new width the new height

Unions the two boxes @a and @b and stores the result in @result.

the first #ClutterActorBox

the second #ClutterActorBox the #ClutterActorBox representing a union of @a and @b

Allocates a new [struct@ActorBox].

the newly allocated #ClutterActorBox. Use [method@ActorBox.free] to free its resources

Clamps the components of @box to the nearest integer

the #ClutterActorBox to clamp

Base class for actors.

signal class handler for [signal@Clutter.Actor::show]; it must chain up to the parent's implementation

A #ClutterActor

signal class handler for [signal@Clutter.Actor::hide]; it must chain up to the parent's implementation

A #ClutterActor

virtual function, used to allocate resources for the actor; it should chain up to the parent's implementation. This virtual function is deprecated and should not be overridden in newly written code.

A #ClutterActor

virtual function, used to deallocate resources allocated in ::realize; it should chain up to the parent's implementation. This function is deprecated and should not be overridden in newly written code.

A #ClutterActor

virtual function for containers and composite actors, to map their children; it must chain up to the parent's implementation. Overriding this function is optional.

A #ClutterActor

virtual function for containers and composite actors, to unmap their children; it must chain up to the parent's implementation. Overriding this function is optional.

A #ClutterActor

virtual function, used to paint the actor

A #ClutterActor

signal class handler for the [signal@Clutter.Actor::parent-set]

signal class handler for [signal@Clutter.Actor::destroy]. It must chain up to the parent's implementation

a #ClutterActor

virtual function, used to draw an outline of the actor with the given color

A #ClutterActor

virtual function, used when querying the minimum and natural widths of an actor for a given height; it is used by clutter_actor_get_preferred_width()

A #ClutterActor 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

virtual function, used when querying the minimum and natural heights of an actor for a given width; it is used by clutter_actor_get_preferred_height()

A #ClutterActor 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

virtual function, used when setting the coordinates of an actor; it is used by clutter_actor_allocate(); when overriding this function without chaining up, clutter_actor_set_allocation() must be called and children must be allocated by the implementation, when chaining up though, those things will be done by the parent's implementation.

A #ClutterActor new allocation of the actor, in parent-relative coordinates