Actor

---

Object Hierarchy:

Description:

Content:

Properties:

• public Action actions { set; }
  Adds a Action to the actor
• public ActorBox allocation { get; }
  The allocation for the actor, in pixels
• public Gravity anchor_gravity { set; get; }
  The anchor point expressed as a Gravity
• public float anchor_x { set; get; }
  The X coordinate of an actor's anchor point, relative to the actor coordinate space, in pixels
• public float anchor_y { set; get; }
  The Y coordinate of an actor's anchor point, relative to the actor coordinate space, in pixels
• public Geometry clip { set; get; }
  The clip region for the actor, in actor-relative coordinates
• public bool clip_to_allocation { set; get; }
  Whether the clip region should track the allocated area of the actor.
• public Constraint constraints { set; }
  Adds a Constraint to the actor
• public float depth { set; get; }
  The position of the actor on the Z axis
• public Effect effect { set; }
  Adds Effect to the list of effects be applied on a Actor
• public bool fixed_position_set { set; get; }
  This flag controls whether the fixed_x and fixed_y properties are used
• public float fixed_x { set; get; }
  The fixed X position of the actor in pixels.
• public float fixed_y { set; get; }
  The fixed Y position of the actor in pixels.
• public bool has_clip { get; }
  Whether the actor has the clip property set or not
• public bool has_pointer { get; }
  Whether the actor contains the pointer of a InputDevice or not.
• public float height { set; get; }
  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.
• public bool mapped { get; }
  Whether the actor is mapped (will be painted when the stage to which it belongs is mapped)
• public float min_height { set; get; }
  A forced minimum height request for the actor, in pixels
• public bool min_height_set { set; get; }
  This flag controls whether the min_height property is used
• public float min_width { set; get; }
  A forced minimum width request for the actor, in pixels
• public bool min_width_set { set; get; }
  This flag controls whether the min_width property is used
• public string name { set; get; }
  The name of the actor
• public float natural_height { set; get; }
  A forced natural height request for the actor, in pixels
• public bool natural_height_set { set; get; }
  This flag controls whether the natural_height property is used
• public float natural_width { set; get; }
  A forced natural width request for the actor, in pixels
• public bool natural_width_set { set; get; }
  This flag controls whether the natural_width property is used
• public OffscreenRedirect offscreen_redirect { set; get; }
  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 set_offscreen_redirect for details.
• public uint opacity { set; get; }
  Opacity of an actor, between 0 (fully transparent) and 255 (fully opaque)
• public bool reactive { set; get; }
  Whether the actor is reactive to events or not
• public bool realized { get; }
  Whether the actor has been realized
• public RequestMode request_mode { set; get; }
  Request mode for the Actor. The request mode determines the type of geometry management used by the actor, either height for width (the default) or width for height.
• public double rotation_angle_x { set; get; }
  The rotation angle on the X axis
• public double rotation_angle_y { set; get; }
  The rotation angle on the Y axis
• public double rotation_angle_z { set; get; }
  The rotation angle on the Z axis
• public Vertex rotation_center_x { set; get; }
  The rotation center on the X axis.
• public Vertex rotation_center_y { set; get; }
  The rotation center on the Y axis.
• public Vertex rotation_center_z { set; get; }
  The rotation center on the Z axis.
• public Gravity rotation_center_z_gravity { set; get; }
  The rotation center on the Z axis expressed as a Gravity .
• public float scale_center_x { set; get; }
  The horizontal center point for scaling
• public float scale_center_y { set; get; }
  The vertical center point for scaling
• public Gravity scale_gravity { set; get; }
  The center point for scaling expressed as a Gravity
• public double scale_x { set; get; }
  The horizontal scale of the actor
• public double scale_y { set; get; }
  The vertical scale of the actor
• public bool show_on_set_parent { set; get; }
  If true, the actor is automatically shown when parented.
• public TextDirection text_direction { set; get; }
• public bool visible { set; get; }
  Whether the actor is set to be visible or not
• public float width { set; get; }
  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.
• public float x { set; get; }
  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.
• public float y { set; get; }
  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.

Static methods:

• public static weak Actor get_by_gid (uint32 id_)
  Retrieves the Actor with id_.

Creation methods:

• protected Actor ()

Methods:

• public void add_action (Action action)
  Adds action to the list of actions applied to self
• public void add_action_with_name (string name, Action action)
  A convenience function for setting the name of a Action while adding it to the list of actions applied to self
• public void add_constraint (Constraint constraint)
  Adds constraint to the list of Constraints applied to self
• public void add_constraint_with_name (string name, Constraint constraint)
  A convenience function for setting the name of a Constraint while adding it to the list of constraints applied to self
• public void add_effect (Effect effect)
  Adds effect to the list of Effect s applied to self
• public void add_effect_with_name (string name, Effect effect)
  A convenience function for setting the name of a Effect while adding it to the list of effectss applied to self
• public virtual void allocate (ActorBox box, AllocationFlags flags)
  Called by the parent of an actor to assign the actor its size. Should never be called by applications (except when implementing a container or layout manager).
• public void allocate_align_fill (ActorBox box, double x_align, double y_align, bool x_fill, bool y_fill, AllocationFlags flags)
  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.
• public void allocate_available_size (float x, float y, float available_width, float available_height, AllocationFlags flags)
  Allocates self taking into account the Actor's preferred size, but limiting it to the maximum available width and height provided.
• public void allocate_preferred_size (AllocationFlags flags)
  Allocates the natural size of self.
• public weak Animation animate (ulong mode, uint duration, ...)
  Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite duration and a speed given by the mode.
• public weak Animation animate_with_alpha (Alpha alpha, ...)
  Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite behaviour given by the passed alpha.
• public weak Animation animate_with_alphav (Alpha alpha, string[] properties, Value[] values)
  Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite behaviour given by the passed alpha.
• public weak Animation animate_with_timeline (ulong mode, Timeline timeline, ...)
  Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite duration given by timeline and a speed given by the mode.
• public weak Animation animate_with_timelinev (ulong mode, Timeline timeline, string[] properties, Value[] values)
  Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite duration given by timeline and a speed given by the mode.
• public weak Animation animatev (ulong mode, uint duration, string[] properties, Value[] values)
  Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite duration and a speed given by the mode.
• public Vertex apply_relative_transform_to_point (Actor? ancestor, Vertex point)
  Transforms point in coordinates relative to the actor into ancestor-relative coordinates using the relevant transform stack (i.e. scale, rotation, etc).
• public virtual void apply_transform (ref Matrix matrix)
• public Vertex apply_transform_to_point (Vertex point)
  Transforms point in coordinates relative to the actor into screen-relative coordinates with the current actor transformation (i.e. scale, rotation, etc)
• public void clear_actions ()
  Clears the list of actions applied to self
• public void clear_constraints ()
  Clears the list of constraints applied to self
• public void clear_effects ()
  Clears the list of effects applied to self
• public bool contains (Actor descendant)
  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.
• public void continue_paint ()
  Run the next stage of the paint sequence. This function should only be called within the implementation of the ‘run’ virtual of a Effect. It will cause the run method of the next effect to be applied, or it will paint the actual actor if the current effect is the last effect in the chain.
• public Context create_pango_context ()
  Creates a Context for the given actor. The Context is already configured using the appropriate font map, resolution and font options.
• public Layout create_pango_layout (string text)
  Creates a new Layout from the same Context used by the Actor. The Layout is already configured with the font map, resolution and font options, and the given text.
• public void detach_animation ()
  Detaches the Animation used by actor, if animate has been called on actor.
• public void get_abs_allocation_vertices (out Vertex[] verts)
  Calculates the transformed screen coordinates of the four corners of the actor; the returned vertices relate to the ActorBox coordinates as follows:
• public virtual weak Object get_accessible ()
  Returns the accessible object that describes the actor to an assistive technology.
• public weak Action get_action (string name)
  Retrieves the Action with the given name in the list of actions applied to self
• public List<weak Action> get_actions ()
  Retrieves the list of actions applied to self
• public ActorBox get_allocation_box ()
  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.
• public Geometry get_allocation_geometry ()
  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.
• public void get_allocation_vertices (Actor? ancestor, out Vertex[] verts)
  Calculates the transformed coordinates of the four corners of the actor in the plane of ancestor . The returned vertices relate to the ActorBox coordinates as follows:
• public void get_anchor_point (out float anchor_x, out float anchor_y)
  Gets the current anchor point of the actor in pixels.
• public Gravity get_anchor_point_gravity ()
  Retrieves the anchor position expressed as a Gravity. If the anchor point was specified using pixels or units this will return NONE .
• public weak Animation get_animation ()
  Retrieves the Animation used by actor, if animate has been called on actor.
• public void get_clip (out float xoff, out float yoff, out float width, out float height)
  Gets the clip area for self, if any is set
• public bool get_clip_to_allocation ()
  Retrieves the value set using set_clip_to_allocation
• public weak Constraint get_constraint (string name)
  Retrieves the Constraint with the given name in the list of constraints applied to self
• public List<weak Constraint> get_constraints ()
  Retrieves the list of constraints applied to self
• public float get_depth ()
  Retrieves the depth of self.
• public weak Effect get_effect (string name)
  Retrieves the Effect with the given name in the list of effects applied to self
• public List<weak Effect> get_effects ()
  Retrieves the Effects applied on self , if any
• public bool get_fixed_position_set ()
  Checks whether an actor has a fixed position set (and will thus be unaffected by any layout manager).
• public ActorFlags get_flags ()
  Retrieves the flags set on self
• public Geometry get_geometry ()
  Gets the size and position of an actor relative to its parent actor. This is the same as calling get_position and get_size. It tries to "do what you mean" and get the requested size and position if the actor's allocation is invalid.
• public uint32 get_gid ()
  Retrieves the unique id for self.
• public bool get_has_pointer ()
  Checks whether an actor contains the pointer of a InputDevice
• public float get_height ()
  Retrieves the height of a Actor.
• public unowned string get_name ()
  Retrieves the name of self.
• public OffscreenRedirect get_offscreen_redirect ()
  Retrieves whether to redirect the actor to an offscreen buffer, as set by set_offscreen_redirect.
• public uint8 get_opacity ()
  Retrieves the opacity value of an actor, as set by set_opacity.
• public bool get_paint_box (out ActorBox box)
  Retrieves the paint volume of the passed Actor , and transforms it into a 2D bounding box in stage coordinates.
• public uint8 get_paint_opacity ()
  Retrieves the absolute opacity of the actor, as it appears on the stage.
• public bool get_paint_visibility ()
  Retrieves the 'paint' visibility of an actor recursively checking for non visible parents.
• public virtual bool get_paint_volume (PaintVolume volume)
  Retrieves the paint volume of the passed Actor , or null when a paint volume can't be determined.
• public weak Context get_pango_context ()
  Retrieves the Context for self. The actor's Context is already configured using the appropriate font map, resolution and font options.
• public weak Actor? get_parent ()
  Retrieves the parent of self.
• public void get_position (out float x, out float y)
  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.
• public virtual void get_preferred_height (float for_width, out float min_height_p, out float natural_height_p)
  Computes the requested minimum and natural heights for an actor, or if they are already computed, returns the cached values.
• public void get_preferred_size (out float min_width_p, out float min_height_p, out float natural_width_p, out float natural_height_p)
  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).
• public virtual void get_preferred_width (float for_height, out float min_width_p, out float natural_width_p)
  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.
• public bool get_reactive ()
  Checks whether actor is marked as reactive.
• public RequestMode get_request_mode ()
  Retrieves the geometry request mode of self
• public double get_rotation (RotateAxis axis, out float x, out float y, out float z)
  Retrieves the angle and center of rotation on the given axis, set using set_rotation.
• public void get_scale (out double scale_x, out double scale_y)
  Retrieves an actors scale factors.
• public void get_scale_center (out float center_x, out float center_y)
  Retrieves the scale center coordinate in pixels relative to the top left corner of the actor. If the scale center was specified using a Gravity this will calculate the pixel offset using the current size of the actor.
• public Gravity get_scale_gravity ()
  Retrieves the scale center as a compass direction. If the scale center was specified in pixels or units this will return NONE.
• public weak Shader get_shader ()
  Queries the currently set Shader on self.
• public void get_size (out float width, out float height)
  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.
• public weak Stage get_stage ()
  Retrieves the Stage where actor is contained.
• public TextDirection get_text_direction ()
  Retrieves the value set using set_text_direction
• public Matrix get_transformation_matrix ()
  Retrieves the transformations applied to self relative to its parent.
• public unowned PaintVolume get_transformed_paint_volume (Actor relative_to_ancestor)
  Retrieves the 3D paint volume of an actor like get_paint_volume does (Please refer to the documentation of get_paint_volume for more details.) 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)
• public void get_transformed_position (out float x, out float y)
  Gets the absolute position of an actor, in pixels relative to the stage.
• public void get_transformed_size (out float width, out float height)
  Gets the absolute size of an actor in pixels, taking into account the scaling factors.
• public float get_width ()
  Retrieves the width of a Actor.
• public float get_x ()
  Retrieves the X coordinate of a Actor.
• public float get_y ()
  Retrieves the Y coordinate of a Actor.
• public Gravity get_z_rotation_gravity ()
  Retrieves the center for the rotation around the Z axis as a compass direction. If the center was specified in pixels or units this will return NONE.
• public void grab_key_focus ()
  Sets the key focus of the Stage including self to this Actor.
• public bool has_allocation ()
  Checks if the actor has an up-to-date allocation assigned to it. This means that the actor should have an allocation: it's visible and has a parent. It also means that there is no outstanding relayout request in progress for the actor or its children (There might be other outstanding layout requests in progress that will cause the actor to get a new allocation when the stage is laid out, however).
• public bool has_key_focus ()
  Checks whether self is the Actor that has key focus
• public virtual bool has_overlaps ()
  Asks the actor's implementation whether it may contain overlapping primitives.
• public virtual void hide_all ()
  Calls clutter_actor_hide on all child actors (if any).
• public bool is_in_clone_paint ()
  Checks whether self is being currently painted by a Clone
• public bool is_rotated ()
  Checks whether any rotation is applied to the actor.
• public bool is_scaled ()
  Checks whether the actor is scaled in either dimension.
• public void lower (Actor? above)
  Puts self below above.
• public void lower_bottom ()
  Lowers self to the bottom.
• public virtual void map ()
  Sets the MAPPED flag on the actor and possibly maps and realizes its children if they are visible. Does nothing if the actor is not visible.
• public void move_anchor_point (float anchor_x, float anchor_y)
  Sets an anchor point for the actor, and adjusts the actor postion so that the relative position of the actor toward its parent remains the same.
• public void move_anchor_point_from_gravity (Gravity gravity)
  Sets an anchor point on the actor based on the given gravity, adjusting the actor postion so that its relative position within its parent remains unchanged.
• public void move_by (float dx, float dy)
  Moves an actor by the specified distance relative to its current position in pixels.
• public void pop_internal ()
  Disables the effects of push_internal
• public void push_internal ()
  Should be used by actors implementing the Container and with internal children added through set_parent, for instance:
• public void queue_redraw ()
  Queues up a redraw of an actor and any children. The redraw occurs once the main loop becomes idle (after the current batch of events has been processed, roughly).
• public void raise (Actor? below)
  Puts self above below.
• public void raise_top ()
  Raises self to the top.
• public void remove_action (Action action)
  Removes action from the list of actions applied to self
• public void remove_action_by_name (string name)
  Removes the Action with the given name from the list of actions applied to self
• public void remove_clip ()
  Removes clip area from self.
• public void remove_constraint (Constraint constraint)
  Removes constraint from the list of constraints applied to self
• public void remove_constraint_by_name (string name)
  Removes the Constraint with the given name from the list of constraints applied to self
• public void remove_effect (Effect effect)
  Removes effect from the list of effects applied to self
• public void remove_effect_by_name (string name)
  Removes the Effect with the given name from the list of effects applied to self
• public void reparent (Actor new_parent)
  This function resets the parent actor of self. It is logically equivalent to calling unparent and set_parent, but more efficiently implemented, ensures the child is not finalized when unparented, and emits the parent-set signal only one time.
• public void set_anchor_point (float anchor_x, float anchor_y)
  Sets an anchor point for self. The anchor point is a point in the coordinate space of an actor to which the actor position within its parent is relative; the default is (0, 0), i.e. the top-left corner of the actor.
• public void set_anchor_point_from_gravity (Gravity gravity)
  Sets an anchor point on the actor, based on the given gravity (this is a convenience function wrapping set_anchor_point).
• public void set_clip (float xoff, float yoff, float width, float height)
  Sets clip area for self. The clip area is always computed from the upper left corner of the actor, even if the anchor point is set otherwise.
• public void set_clip_to_allocation (bool clip_set)
  Sets whether self should be clipped to the same size as its allocation
• public void set_depth (float depth)
  Sets the Z coordinate of self to depth.
• public void set_fixed_position_set (bool is_set)
  Sets whether an actor has a fixed position set (and will thus be unaffected by any layout manager).
• public void set_flags (ActorFlags flags)
  Sets flags on self
• public void set_geometry (Geometry geometry)
  Sets the actor's fixed position and forces its minimum and natural size, in pixels. This means the untransformed actor will have the given geometry. This is the same as calling set_position and set_size.
• public void set_height (float height)
  Forces a height on an actor, causing the actor's preferred width and height (if any) to be ignored.
• public void set_name (string name)
  Sets the given name to self. The name can be used to identify a Actor.
• public void set_offscreen_redirect (OffscreenRedirect redirect)
• public void set_opacity (uint8 opacity)
  Sets the actor's opacity, with zero being completely transparent and 255 (0xff) being fully opaque.
• public void set_parent (Actor parent)
  Sets the parent of self to parent. The opposite function is unparent.
• public void set_position (float x, float y)
  Sets the actor's fixed position in pixels relative to any parent actor.
• public void set_reactive (bool reactive)
  Sets actor as reactive. Reactive actors will receive events.
• public void set_request_mode (RequestMode mode)
  Sets the geometry request mode of self.
• public void set_rotation (RotateAxis axis, double angle, float x, float y, float z)
  Sets the rotation angle of self around the given axis.
• public void set_scale (double scale_x, double scale_y)
  Scales an actor with the given factors. The scaling is relative to the scale center and the anchor point. The scale center is unchanged by this function and defaults to 0,0.
• public void set_scale_full (double scale_x, double scale_y, float center_x, float center_y)
  Scales an actor with the given factors around the given center point. The center point is specified in pixels relative to the anchor point (usually the top left corner of the actor).
• public void set_scale_with_gravity (double scale_x, double scale_y, Gravity gravity)
  Scales an actor with the given factors around the given center point. The center point is specified as one of the compass directions in Gravity. For example, setting it to north will cause the top of the actor to remain unchanged and the rest of the actor to expand left, right and downwards.
• public bool set_shader (Shader? shader)
  Sets the Shader to be used when rendering self .
• public void set_shader_param (string param, Value value)
  Sets the value for a named parameter of the shader applied to actor.
• public void set_shader_param_float (string param, float value)
  Sets the value for a named float parameter of the shader applied to actor.
• public void set_shader_param_int (string param, int value)
  Sets the value for a named int parameter of the shader applied to actor.
• public void set_size (float width, float height)
  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.
• public void set_text_direction (TextDirection text_dir)
  Sets the TextDirection for an actor
• public void set_width (float width)
  Forces a width on an actor, causing the actor's preferred width and height (if any) to be ignored.
• public void set_x (float x)
  Sets the actor's X coordinate, relative to its parent, in pixels.
• public void set_y (float y)
  Sets the actor's Y coordinate, relative to its parent, in pixels.#
• public void set_z_rotation_from_gravity (double angle, Gravity gravity)
  Sets the rotation angle of self around the Z axis using the center point specified as a compass point. For example to rotate such that the center of the actor remains static you can use CENTER. If the actor changes size the center point will move accordingly.
• public bool should_pick_paint ()
  Should be called inside the implementation of the pick virtual function in order to check whether the actor should paint itself in pick mode or not.
• public virtual void show_all ()
  Calls clutter_actor_show on all children of an actor (if any).
• public bool transform_stage_point (float x, float y, out float x_out, out float y_out)
  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.
• public virtual void unmap ()
  Unsets the MAPPED flag on the actor and possibly unmaps its children if they were mapped.
• public void unparent ()
  Removes the parent of self.
• public void unset_flags (ActorFlags flags)
  Unsets flags on self

Signals:

• public void allocation_changed (ActorBox box, AllocationFlags flags)
  The allocation_changed signal is emitted when the allocation property changes. Usually, application code should just use the notifications for the allocation property but if you want to track the allocation flags as well, for instance to know whether the absolute origin of actor changed, then you might want use this signal instead.
• public virtual bool button_press_event (ButtonEvent event)
  The button_press_event signal is emitted each time a mouse button is pressed on actor.
• public virtual bool button_release_event (ButtonEvent event)
  The button_release_event signal is emitted each time a mouse button is released on actor.
• public virtual bool captured_event (Event event)
  The captured_event signal is emitted when an event is captured by Clutter. This signal will be emitted starting from the top-level container (the 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 ClutterActor::button-press-event or ::key-released-event) are emitted.
• public virtual void destroy ()
  The destroy signal notifies that all references held on the actor which emitted it should be released.
• public virtual bool enter_event (CrossingEvent event)
  The enter_event signal is emitted when the pointer enters the actor
• public virtual bool event ()
  The event signal is emitted each time an event is received by the actor. This signal will be emitted on every actor, following the hierarchy chain, until it reaches the top-level container (the Stage).
• public virtual void hide ()
  The hide signal is emitted when an actor is no longer rendered on the stage.
• public virtual void key_focus_in ()
  The key_focus_in signal is emitted when actor receives key focus.
• public virtual void key_focus_out ()
  The key_focus_out signal is emitted when actor loses key focus.
• public virtual bool key_press_event (KeyEvent event)
  The key_press_event signal is emitted each time a keyboard button is pressed while actor has key focus (see set_key_focus).
• public virtual bool key_release_event (KeyEvent event)
  The key_release_event signal is emitted each time a keyboard button is released while actor has key focus (see set_key_focus).
• public virtual bool leave_event (CrossingEvent event)
  The leave_event signal is emitted when the pointer leaves the actor.
• public virtual bool motion_event (MotionEvent event)
  The motion_event signal is emitted each time the mouse pointer is moved over actor.
• public virtual void paint ()
  The paint signal is emitted each time an actor is being painted.
• public virtual void parent_set (Actor? old_parent)
  This signal is emitted when the parent of the actor changes.
• public virtual void pick (Color color)
  The pick signal is emitted each time an actor is being painted in "pick mode". The pick mode is used to identify the actor during the event handling phase, or by get_actor_at_pos. The actor should paint its shape using the passed pick_color.
• public virtual void queue_relayout ()
  The ::queue_layout signal is emitted when clutter_actor_queue_relayout is called on an actor.
• public virtual void realize ()
  The realize signal is emitted each time an actor is being realized.
• public virtual bool scroll_event (ScrollEvent event)
  The scroll_event signal is emitted each time the mouse is scrolled on actor
• public virtual void show ()
  The show signal is emitted when an actor is visible and rendered on the stage.
• public virtual void unrealize ()
  The unrealize signal is emitted each time an actor is being unrealized.

Fields:

• public uint32 flags