CLUTTER_ACTOR_SET_FLAGS()

#define CLUTTER_ACTOR_SET_FLAGS(a,f)    (((ClutterActor*)(a))->flags |= (f))

Sets the given flags on a ClutterActor

CLUTTER_ACTOR_UNSET_FLAGS()

#define CLUTTER_ACTOR_UNSET_FLAGS(a,f)  (((ClutterActor*)(a))->flags &= ~(f))

Unsets the given flags on a ClutterActor

CLUTTER_ACTOR_IS_MAPPED()

#define CLUTTER_ACTOR_IS_MAPPED(e)      (((ClutterActor*)(e))->flags & CLUTTER_ACTOR_MAPPED)

Evaluates to TRUE if the CLUTTER_ACTOR_MAPPED flag is set.

Since 0.2

CLUTTER_ACTOR_IS_REALIZED()

#define CLUTTER_ACTOR_IS_REALIZED(e)    (((ClutterActor*)(e))->flags & CLUTTER_ACTOR_REALIZED)

Evaluates to TRUE if the CLUTTER_ACTOR_REALIZED flag is set.

Since 0.2

CLUTTER_ACTOR_IS_VISIBLE()

#define CLUTTER_ACTOR_IS_VISIBLE(e)     (CLUTTER_ACTOR_IS_MAPPED (e) && CLUTTER_ACTOR_IS_REALIZED (e))

Evaluates to TRUE if the actor is both realized and mapped.

Since 0.2

CLUTTER_ACTOR_IS_REACTIVE()

#define CLUTTER_ACTOR_IS_REACTIVE(e)    (((ClutterActor*)(e))->flags & CLUTTER_ACTOR_REACTIVE)

Evaluates to TRUE if the CLUTTER_ACTOR_REACTIVE flag is set.

Since 0.6

ClutterActorBox

typedef struct {
  ClutterUnit x1;
  ClutterUnit y1;
  ClutterUnit x2;
  ClutterUnit y2;
} ClutterActorBox;

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 ClutterUnits, that is are device-independent. If you want to obtain the box dimensions in pixels, use clutter_actor_get_geometry().

enum ClutterActorFlags

typedef enum
{
  CLUTTER_ACTOR_MAPPED   = 1 << 1,
  CLUTTER_ACTOR_REALIZED = 1 << 2,
  CLUTTER_ACTOR_REACTIVE = 1 << 3
} ClutterActorFlags;

Flags used to signal the state of an actor.

ClutterGeometry

typedef struct {
  gint   x;
  gint   y;
  guint  width;
  guint  height;
} ClutterGeometry;

The rectangle containing an actor's bounding box, measured in pixels.

CLUTTER_CALLBACK()

#define CLUTTER_CALLBACK(f)        ((ClutterCallback) (f))

Convenience macro to cast a function to ClutterCallback

ClutterCallback ()

void                (*ClutterCallback)                  (ClutterActor *actor,
                                                         gpointer data);

Generic callback

ClutterActor

typedef struct {
  guint32 flags;
} ClutterActor;

Base class for actors.

ClutterActorClass

typedef struct {
  void (* show)            (ClutterActor        *actor);
  void (* show_all)        (ClutterActor        *actor);
  void (* hide)            (ClutterActor        *actor);
  void (* hide_all)        (ClutterActor        *actor);
  void (* realize)         (ClutterActor        *actor);
  void (* unrealize)       (ClutterActor        *actor);
  void (* paint)           (ClutterActor        *actor);
  void (* request_coords)  (ClutterActor        *actor,
                            ClutterActorBox     *box);
  void (* query_coords)    (ClutterActor        *actor,
                            ClutterActorBox     *box);
  void (* parent_set)      (ClutterActor        *actor,
                            ClutterActor        *old_parent);

  void (* destroy)         (ClutterActor        *actor);
  void (* pick)            (ClutterActor        *actor,
                            const ClutterColor  *color);

  /* event signals */
  gboolean (* event)                (ClutterActor         *actor,
                                     ClutterEvent         *event);
  gboolean (* button_press_event)   (ClutterActor         *actor,
                                     ClutterButtonEvent   *event);
  gboolean (* button_release_event) (ClutterActor         *actor,
                                     ClutterButtonEvent   *event);
  gboolean (* scroll_event)         (ClutterActor         *actor,
                                     ClutterScrollEvent   *event);
  gboolean (* key_press_event)      (ClutterActor         *actor,
                                     ClutterKeyEvent      *event);
  gboolean (* key_release_event)    (ClutterActor         *actor,
                                     ClutterKeyEvent      *event);
  gboolean (* motion_event)         (ClutterActor         *actor,
                                     ClutterMotionEvent   *event);
  gboolean (* enter_event)          (ClutterActor         *actor,
                                     ClutterCrossingEvent *event);
  gboolean (* leave_event)          (ClutterActor         *actor,
                                     ClutterCrossingEvent *event);
  gboolean (* captured_event)       (ClutterActor         *actor,
                                     ClutterEvent         *event);
  void     (* focus_in)             (ClutterActor         *actor);
  void     (* focus_out)            (ClutterActor         *actor);
} ClutterActorClass;

Base class for actors.

clutter_actor_show ()

void                clutter_actor_show                  (ClutterActor *self);

Flags an actor to be displayed. An actor that isn't shown will not be rendered on the stage.

clutter_actor_show_all ()

void                clutter_actor_show_all              (ClutterActor *self);

Call show() on all children of an actor (if any).

Since 0.2

clutter_actor_hide ()

void                clutter_actor_hide                  (ClutterActor *self);

Flags an actor to be hidden. A hidden actor will not be rendered on the stage.

clutter_actor_hide_all ()

void                clutter_actor_hide_all              (ClutterActor *self);

Call hide() on all child actors (if any).

Since 0.2

clutter_actor_realize ()

void                clutter_actor_realize               (ClutterActor *self);

Creates any underlying graphics resources needed by the actor to be displayed.

clutter_actor_unrealize ()

void                clutter_actor_unrealize             (ClutterActor *self);

Frees up any underlying graphics resources needed by the actor to be displayed.

clutter_actor_paint ()

void                clutter_actor_paint                 (ClutterActor *self);

Renders the actor to display.

This function should not be called directly by applications. Call clutter_actor_queue_redraw() to queue paints, instead.

clutter_actor_queue_redraw ()

void                clutter_actor_queue_redraw          (ClutterActor *self);

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.

clutter_actor_destroy ()

void                clutter_actor_destroy               (ClutterActor *self);

Destroys an actor. When an actor is destroyed, it will break any references it holds to other objects. If the actor is inside a container, the actor will be removed.

When you destroy a container, its children will be destroyed as well.

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

clutter_actor_request_coords ()

void                clutter_actor_request_coords        (ClutterActor *self,
                                                         ClutterActorBox *box);

Requests new untransformed coordinates for the bounding box of a ClutterActor. The coordinates must be relative to the current parent of the actor.

This function should not be called directly by applications; instead, the various position/geometry methods should be used.

Note: Actors overriding the ClutterActor::request_coords() virtual function should always chain up to the parent class request_coords() method. Actors should override this function only if they need to recompute some internal state or need to reposition their children.

clutter_actor_query_coords ()

void                clutter_actor_query_coords          (ClutterActor *self,
                                                         ClutterActorBox *box);

Requests the untransformed co-ordinates (in ClutterUnits) for the ClutterActor, relative to any parent.

This function should not be called directly by applications. The various position/geometry methods should be used instead.

clutter_actor_event ()

gboolean            clutter_actor_event                 (ClutterActor *actor,
                                                         ClutterEvent *event,
                                                         gboolean capture);

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

Since 0.6

clutter_actor_pick ()

void                clutter_actor_pick                  (ClutterActor *self,
                                                         const ClutterColor *color);

Renders a silhouette of the actor using the supplied color. Used internally for mapping pointer events to actors.

This function should never be called directly by applications.

Subclasses overiding the ClutterActor::pick() method should call clutter_actor_should_pick_paint() to decide whether to render their silhouette. Containers should always recursively call pick for each child.

Since 0.4

clutter_actor_should_pick_paint ()

gboolean            clutter_actor_should_pick_paint     (ClutterActor *self);

Utility call for subclasses overiding the pick method.

This function should never be called directly by applications.

clutter_actor_set_geometry ()

void                clutter_actor_set_geometry          (ClutterActor *self,
                                                         const ClutterGeometry *geometry);

Sets the actor's untransformed geometry in pixels relative to any parent actor.

clutter_actor_get_geometry ()

void                clutter_actor_get_geometry          (ClutterActor *self,
                                                         ClutterGeometry *geometry);

Gets the actor's untransformed geometry in pixels relative to any parent actor.

clutter_actor_get_coords ()

void                clutter_actor_get_coords            (ClutterActor *self,
                                                         gint *x_1,
                                                         gint *y_1,
                                                         gint *x_2,
                                                         gint *y_2);

Gets the actor's untransformed bounding rectangle coordinates in pixels relative to any parent actor.

clutter_actor_set_size ()

void                clutter_actor_set_size              (ClutterActor *self,
                                                         gint width,
                                                         gint height);

Sets the actor's size in pixels.

If width and/or height are -1 the actor will assume the same size of its bounding box.

clutter_actor_get_size ()

void                clutter_actor_get_size              (ClutterActor *self,
                                                         guint *width,
                                                         guint *height);

Gets the size of an actor in pixels, ignoring any scaling factors.

Since 0.2

clutter_actor_set_position ()

void                clutter_actor_set_position          (ClutterActor *self,
                                                         gint x,
                                                         gint y);

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

clutter_actor_get_position ()

void                clutter_actor_get_position          (ClutterActor *self,
                                                         gint *x,
                                                         gint *y);

Retrieves the position of an actor.

Since 0.6

clutter_actor_get_abs_position ()

void                clutter_actor_get_abs_position      (ClutterActor *self,
                                                         gint *x,
                                                         gint *y);

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

clutter_actor_set_width ()

void                clutter_actor_set_width             (ClutterActor *self,
                                                         guint width);

Requests a new width for the actor

Since 0.2

clutter_actor_get_width ()

guint               clutter_actor_get_width             (ClutterActor *self);

Retrieves the actor's width ignoring any scaling factors.

clutter_actor_set_height ()

void                clutter_actor_set_height            (ClutterActor *self,
                                                         guint height);

Requests a new height for the actor

Since 0.2

clutter_actor_get_height ()

guint               clutter_actor_get_height            (ClutterActor *self);

Retrieves the actor's height ignoring any scaling factors.

clutter_actor_set_x ()

void                clutter_actor_set_x                 (ClutterActor *self,
                                                         gint x);

Sets the actor's X coordinate, relative to its parent.

Since 0.6

clutter_actor_get_x ()

gint                clutter_actor_get_x                 (ClutterActor *self);

Retrieves the actor's X coordinate, relative to any parent.

clutter_actor_set_y ()

void                clutter_actor_set_y                 (ClutterActor *self,
                                                         gint y);

Sets the actor's Y coordinate, relative to its parent.

Since 0.6

clutter_actor_get_y ()

gint                clutter_actor_get_y                 (ClutterActor *self);

Retrieves the actor's Y coordinate, relative to any parent.

clutter_actor_move_by ()

void                clutter_actor_move_by               (ClutterActor *self,
                                                         gint dx,
                                                         gint dy);

Moves an actor by the specified distance relative to its current position in pixels.

Since 0.2

clutter_actor_set_rotation ()

void                clutter_actor_set_rotation          (ClutterActor *self,
                                                         ClutterRotateAxis axis,
                                                         gdouble angle,
                                                         gint x,
                                                         gint y,
                                                         gint z);

Sets the rotation angle of self around the given axis.

The rotation center coordinates used depend on the value of axis:

The rotation coordinates are relative to the anchor point of the actor, set using clutter_actor_set_anchor_point(). If no anchor point is set, the upper left corner is assumed as the origin.

Since 0.6

clutter_actor_get_rotation ()

gdouble             clutter_actor_get_rotation          (ClutterActor *self,
                                                         ClutterRotateAxis axis,
                                                         gint *x,
                                                         gint *y,
                                                         gint *z);

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

The coordinates of the center returned by this function depend on the axis passed.

Since 0.6

clutter_actor_is_rotated ()

gboolean            clutter_actor_is_rotated            (ClutterActor *self);

Checks whether any rotation is applied to the actor.

Since 0.6

clutter_actor_set_opacity ()

void                clutter_actor_set_opacity           (ClutterActor *self,
                                                         guint8 opacity);

Sets the actor's opacity, with zero being completely transparent and 255 (0xff) being fully opaque.

clutter_actor_get_opacity ()

guint8              clutter_actor_get_opacity           (ClutterActor *self);

Retrieves the actor's opacity.

clutter_actor_set_name ()

void                clutter_actor_set_name              (ClutterActor *self,
                                                         const gchar *name);

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

clutter_actor_get_name ()

const gchar*        clutter_actor_get_name              (ClutterActor *self);

Retrieves the name of self.

clutter_actor_get_gid ()

guint32             clutter_actor_get_gid               (ClutterActor *self);

Retrieves the unique id for self.

Since 0.6

clutter_actor_set_clip ()

void                clutter_actor_set_clip              (ClutterActor *self,
                                                         gint xoff,
                                                         gint yoff,
                                                         gint width,
                                                         gint height);

Sets clip area in pixels for self. The clip area is always computed from the upper left corner of the actor, even if the anchor point is set otherwise.

clutter_actor_remove_clip ()

void                clutter_actor_remove_clip           (ClutterActor *self);

Removes clip area from self.

clutter_actor_has_clip ()

gboolean            clutter_actor_has_clip              (ClutterActor *self);

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

Since 0.1.1

clutter_actor_get_clip ()

void                clutter_actor_get_clip              (ClutterActor *self,
                                                         gint *xoff,
                                                         gint *yoff,
                                                         gint *width,
                                                         gint *height);

Gets the clip area for self, in pixels.

Since 0.6

clutter_actor_set_parent ()

void                clutter_actor_set_parent            (ClutterActor *self,
                                                         ClutterActor *parent);

Sets the parent of self to parent. The opposite function is clutter_actor_unparent().

This function should not be used by applications, but by custom 'composite' actor subclasses.