Class Point

A #ClutterAction can only belong to one actor at a time

The #ClutterActor will hold a reference on action until either clutter_actor_remove_action() or clutter_actor_clear_actions() is called

This function is the logical equivalent of:

  clutter_actor_meta_set_name (CLUTTER_ACTOR_META (action), name);
  clutter_actor_add_action (self, action);

This function will call #ClutterContainerIface.add(), which is a deprecated virtual function. The default implementation will call clutter_actor_add_child().

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

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

This function will emit the #ClutterContainer::actor-added signal on self.

The #ClutterActor will hold a reference on the constraint until either clutter_actor_remove_constraint() or clutter_actor_clear_constraints() is called.

This function is the logical equivalent of:

  clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), name);
  clutter_actor_add_constraint (self, constraint);

The #ClutterActor will hold a reference on the effect until either clutter_actor_remove_effect() or clutter_actor_clear_effects() is called.

Note that as #ClutterEffect is initially unowned, clutter_actor_add_effect() will sink any floating reference on effect.

Note that as #ClutterEffect is initially unowned, clutter_actor_add_effect_with_name() will sink any floating reference on effect.

This function is the logical equivalent of:

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

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.

This function should only be called on the children of an actor when overriding the #ClutterActorClass.allocate() virtual function.

This function will adjust the stored allocation to take into account the alignment flags set in the #ClutterActor:x-align and #ClutterActor:y-align properties, as well as the margin values set in the #ClutterActor:margin-top, #ClutterActor:margin-right, #ClutterActor:margin-bottom, and #ClutterActor: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.

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

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

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

This function will do the right thing when dealing with the actor's request mode.

The implementation of this function is equivalent to:

  if (request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
    {
      clutter_actor_get_preferred_width (self, available_height,
                                         &min_width,
                                         &natural_width);
      width = CLAMP (natural_width, min_width, available_width);

      clutter_actor_get_preferred_height (self, width,
                                          &min_height,
                                          &natural_height);
      height = CLAMP (natural_height, min_height, available_height);
    }
  else if (request_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
    {
      clutter_actor_get_preferred_height (self, available_width,
                                          &min_height,
                                          &natural_height);
      height = CLAMP (natural_height, min_height, available_height);

      clutter_actor_get_preferred_width (self, height,
                                         &min_width,
                                         &natural_width);
      width = CLAMP (natural_width, min_width, available_width);
    }
  else if (request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
    {
      clutter_content_get_preferred_size (content, &natural_width, &natural_height);

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

  box.x1 = x; box.y1 = y;
  box.x2 = box.x1 + available_width;
  box.y2 = box.y1 + available_height;
  clutter_actor_allocate (self, &box, flags);

This function can be used by fluid layout managers to allocate an actor's preferred size without making it bigger than the area available for the container.

This function is a utility call for #ClutterActor implementations that allocates the actor's preferred natural size. It can be used by fixed layout managers (like #ClutterGroup or so called 'composite actors') inside the ClutterActor::allocate implementation to give each child exactly how much space it requires, 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.

The initial_value and final_value #GValues must contain the same type; value must have been initialized to the same type of initial_value and final_value.

All implementation of the #ClutterAnimatable interface must implement this function.

See clutter_actor_animate() for further details.

This function is useful if you want to use an existing #ClutterAlpha to animate actor.

This is the vector-based variant of clutter_actor_animate_with_alpha(), useful for language bindings.

Unlike clutter_actor_animate_with_alpha(), this function will not allow you to specify "signal::" names and callbacks.

See clutter_actor_animate() for further details.

This function is useful if you want to use an existing timeline to animate actor.

This is the vector-based variant of clutter_actor_animate_with_timeline(), useful for language bindings.

Unlike clutter_actor_animate_with_timeline(), this function will not allow you to specify "signal::" names and callbacks.

This is the vector-based variant of clutter_actor_animate(), useful for language bindings.

Unlike clutter_actor_animate(), this function will not allow you to specify "signal::" names and callbacks.

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

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.

Whenever the source_property is changed the target_property is updated using the same value. For instance:

  g_object_bind_property (action, "active", widget, "sensitive", 0);

Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance.

If flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual: if target_property on target changes then the source_property on source will be updated as well.

The binding will automatically be removed when either the source or the target instances are finalized. To remove the binding without affecting the source and the target you can just call g_object_unref() on the returned #GBinding instance.

Removing the binding by calling g_object_unref() on it must only be done if the binding, source and target are only used from a single thread and it is clear that both source and target outlive the binding. Especially it is not safe to rely on this if the binding, source or target can be finalized from different threads. Keep another reference to the binding and use g_binding_unbind() instead to be on the safe side.

A #GObject can have multiple bindings.

This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.

Note that clutter_container_child_set_property() is really intended for language bindings, clutter_container_child_set() is much more convenient for C programming.