GI.Clutter.Objects.Actor

Base class for actors.

Exported types

newtype Actor

Memory-managed wrapper type.

Constructors

Actor (ManagedPtr Actor)

Instances

Eq Actor

Defined in GI.Clutter.Objects.Actor

Methods

(==) :: Actor -> Actor -> Bool

(/=) :: Actor -> Actor -> Bool

GObject Actor

Defined in GI.Clutter.Objects.Actor

ManagedPtrNewtype Actor

Defined in GI.Clutter.Objects.Actor

Methods

toManagedPtr :: Actor -> ManagedPtr Actor

TypedObject Actor

Defined in GI.Clutter.Objects.Actor

Methods

glibType :: IO GType

HasParentTypes Actor

Defined in GI.Clutter.Objects.Actor

IsGValue (Maybe Actor)

Convert Actor to and from GValue. See toGValue and fromGValue.

Defined in GI.Clutter.Objects.Actor

Methods

gvalueGType_ :: IO GType

gvalueSet_ :: Ptr GValue -> Maybe Actor -> IO ()

gvalueGet_ :: Ptr GValue -> IO (Maybe Actor)

type ParentTypes Actor

Defined in GI.Clutter.Objects.Actor

type ParentTypes Actor = '[Object, ImplementorIface, Animatable, Container, Scriptable]

class (GObject o, IsDescendantOf Actor o) => IsActor o

Type class for types which can be safely cast to Actor, for instance with toActor.

Instances

(GObject o, IsDescendantOf Actor o) => IsActor o

Defined in GI.Clutter.Objects.Actor

toActor :: (MonadIO m, IsActor o) => o -> m Actor

Cast to Actor, for types for which this is known to be safe. For general casts, use castTo.

Methods

Click to display all available methods, including inherited ones

Methods

addAction, addActionWithName, addActor, addChild, addConstraint, addConstraintWithName, addEffect, addEffectWithName, addTransition, allocate, allocateAlignFill, allocateAvailableSize, allocatePreferredSize, animateProperty, animateWithAlphav, animateWithTimelinev, animatev, applyRelativeTransformToPoint, applyTransformToPoint, bindModel, bindProperty, bindPropertyFull, childGetProperty, childNotify, childSetProperty, clearActions, clearConstraints, clearEffects, contains, continuePaint, createChildMeta, createPangoContext, createPangoLayout, destroy, destroyAllChildren, destroyChildMeta, detachAnimation, event, findChildByName, findProperty, forceFloating, foreach, foreachWithInternals, freezeNotify, getv, grabKeyFocus, hasActions, hasAllocation, hasClip, hasConstraints, hasEffects, hasKeyFocus, hasOverlaps, hasPointer, hide, hideAll, insertChildAbove, insertChildAtIndex, insertChildBelow, interpolateValue, isFloating, isInClonePaint, isMapped, isRealized, isRotated, isScaled, isVisible, lower, lowerBottom, lowerChild, map, moveAnchorPoint, moveAnchorPointFromGravity, moveBy, needsExpand, notify, notifyByPspec, paint, parseCustomNode, popInternal, pushInternal, queueRedraw, queueRedrawWithClip, queueRelayout, raise, raiseChild, raiseTop, realize, ref, refSink, removeAction, removeActionByName, removeActor, removeAllChildren, removeAllTransitions, removeChild, removeClip, removeConstraint, removeConstraintByName, removeEffect, removeEffectByName, removeTransition, reparent, replaceChild, restoreEasingState, runDispose, saveEasingState, shouldPickPaint, show, showAll, sortDepthOrder, stealData, stealQdata, thawNotify, transformStagePoint, unmap, unparent, unrealize, unref, unsetFlags, watchClosure.

Getters

getAbsAllocationVertices, getAccessible, getAction, getActions, getAllocationBox, getAllocationGeometry, getAllocationVertices, getAnchorPoint, getAnchorPointGravity, getAnimation, getBackgroundColor, getChildAtIndex, getChildMeta, getChildTransform, getChildren, getClip, getClipToAllocation, getConstraint, getConstraints, getContent, getContentBox, getContentGravity, getContentRepeat, getContentScalingFilters, getData, getDefaultPaintVolume, getDepth, getEasingDelay, getEasingDuration, getEasingMode, getEffect, getEffects, getFirstChild, getFixedPositionSet, getFlags, getGeometry, getGid, getHeight, getId, getInitialState, getLastChild, getLayoutManager, getMargin, getMarginBottom, getMarginLeft, getMarginRight, getMarginTop, getNChildren, getName, getNextSibling, getOffscreenRedirect, getOpacity, getPaintBox, getPaintOpacity, getPaintVisibility, getPaintVolume, getPangoContext, getParent, getPivotPoint, getPivotPointZ, getPosition, getPreferredHeight, getPreferredSize, getPreferredWidth, getPreviousSibling, getProperty, getQdata, getReactive, getRequestMode, getRotation, getRotationAngle, getScale, getScaleCenter, getScaleGravity, getScaleZ, getShader, getSize, getStage, getTextDirection, getTransform, getTransformationMatrix, getTransformedPaintVolume, getTransformedPosition, getTransformedSize, getTransition, getTranslation, getWidth, getX, getXAlign, getXExpand, getY, getYAlign, getYExpand, getZPosition, getZRotationGravity.

Setters

setAllocation, setAnchorPoint, setAnchorPointFromGravity, setBackgroundColor, setChildAboveSibling, setChildAtIndex, setChildBelowSibling, setChildTransform, setClip, setClipToAllocation, setContent, setContentGravity, setContentRepeat, setContentScalingFilters, setCustomProperty, setData, setDataFull, setDepth, setEasingDelay, setEasingDuration, setEasingMode, setFinalState, setFixedPositionSet, setFlags, setGeometry, setHeight, setId, setLayoutManager, setMargin, setMarginBottom, setMarginLeft, setMarginRight, setMarginTop, setName, setOffscreenRedirect, setOpacity, setParent, setPivotPoint, setPivotPointZ, setPosition, setProperty, setReactive, setRequestMode, setRotation, setRotationAngle, setScale, setScaleFull, setScaleWithGravity, setScaleZ, setShader, setShaderParam, setShaderParamFloat, setShaderParamInt, setSize, setTextDirection, setTransform, setTranslation, setWidth, setX, setXAlign, setXExpand, setY, setYAlign, setYExpand, setZPosition, setZRotationFromGravity.

addAction

actorAddAction

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsAction b)

=> a

self: a Actor

-> b

action: a Action

-> m ()

Adds action to the list of actions applied to self

A Action can only belong to one actor at a time

The Actor will hold a reference on action until either actorRemoveAction or actorClearActions is called

Since: 1.4

addActionWithName

actorAddActionWithName

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsAction b)

=> a

self: a Actor

-> Text

name: the name to set on the action

-> b

action: a Action

-> m ()

A convenience function for setting the name of a Action while adding it to the list of actions applied to self

This function is the logical equivalent of:

C code

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

Since: 1.4

addChild

actorAddChild

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: a Actor

-> b

child: a Actor

-> m ()

Adds child to the children of self.

This function will acquire a reference on child that will only be released when calling actorRemoveChild.

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

This function will emit the actorAdded signal on self.

Since: 1.10

addConstraint

actorAddConstraint

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsConstraint b)

=> a

self: a Actor

-> b

constraint: a Constraint

-> m ()

Adds constraint to the list of Constraints applied to self

The Actor will hold a reference on the constraint until either actorRemoveConstraint or actorClearConstraints is called.

Since: 1.4

addConstraintWithName

actorAddConstraintWithName

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsConstraint b)

=> a

self: a Actor

-> Text

name: the name to set on the constraint

-> b

constraint: a Constraint

-> m ()

A convenience function for setting the name of a Constraint while adding it to the list of constraints applied to self

This function is the logical equivalent of:

C code

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

Since: 1.4

addEffect

actorAddEffect

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsEffect b)

=> a

self: a Actor

-> b

effect: a Effect

-> m ()

Adds effect to the list of Effects applied to self

The Actor will hold a reference on the effect until either actorRemoveEffect or actorClearEffects is called.

Note that as Effect is initially unowned, actorAddEffect will sink any floating reference on effect.

Since: 1.4

addEffectWithName

actorAddEffectWithName

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsEffect b)

=> a

self: a Actor

-> Text

name: the name to set on the effect

-> b

effect: a Effect

-> m ()

A convenience function for setting the name of a Effect while adding it to the list of effects applied to self.

Note that as Effect is initially unowned, actorAddEffectWithName will sink any floating reference on effect.

This function is the logical equivalent of:

C code

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

Since: 1.4

addTransition

actorAddTransition

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsTransition b)

=> a

self: a Actor

-> Text

name: the name of the transition to add

-> b

transition: the Transition to add

-> m ()

Adds a transition to the Actor's list of animations.

The name string is a per-actor unique identifier of the transition: only one Transition 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.

Since: 1.10

allocate

actorAllocate

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> ActorBox

box: new allocation of the actor, in parent-relative coordinates

-> [AllocationFlags]

flags: flags that control the allocation

-> m ()

Assigns the size of a Actor from the given box.

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

This function will adjust the stored allocation to take into account the alignment flags set in the Actor:x-align and Actor:y-align properties, as well as the margin values set in the Actor:margin-top, Actor:margin-right, Actor:margin-bottom, and Actor:margin-left properties.

This function will respect the easing state of the Actor 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.

Since: 0.8

allocateAlignFill

actorAllocateAlignFill

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> ActorBox

box: a ActorBox, containing the available width and height

-> Double

xAlign: the horizontal alignment, between 0 and 1

-> Double

yAlign: the vertical alignment, between 0 and 1

-> Bool

xFill: whether the actor should fill horizontally

-> Bool

yFill: whether the actor should fill vertically

-> [AllocationFlags]

flags: allocation flags to be passed to actorAllocate

-> m ()

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 ActorBox are not set to 0, the allocation will be offset by their value.

This function takes into consideration the geometry request specified by the 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 Actor:x-align and Actor:y-align properties, instead, and just call actorAllocate inside their ActorClass.allocate() implementation.

Since: 1.4

allocateAvailableSize

actorAllocateAvailableSize

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

x: the actor's X coordinate

-> Float

y: the actor's Y coordinate

-> Float

availableWidth: the maximum available width, or -1 to use the actor's natural width

-> Float

availableHeight: the maximum available height, or -1 to use the actor's natural height

-> [AllocationFlags]

flags: flags controlling the allocation

-> m ()

Allocates self taking into account the Actor'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 code

 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.

Since: 1.0

allocatePreferredSize

actorAllocatePreferredSize

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> [AllocationFlags]

flags: flags controlling the allocation

-> m ()

Allocates the natural size of self.

This function is a utility call for Actor implementations that allocates the actor's preferred natural size. It can be used by fixed layout managers (like Group or so called 'composite actors') inside the ClutterActor[allocate](#g:signal: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 ActorClass.allocate virtual function.

Since: 0.8

animateWithAlphav

actorAnimateWithAlphav

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsAlpha b)

=> a

actor: a Actor

-> b

alpha: a Alpha

-> [Text]

properties: a vector containing the property names to set

-> [GValue]

values: a vector containing the property values to set

-> m Animation

Returns: a Animation object. The object is owned by the Actor and should not be unreferenced with objectUnref

Deprecated: (Since version 1.10)Use the implicit transition for animatable properties in Actor instead. See actorSaveEasingState, actorSetEasingMode, actorSetEasingDuration, actorSetEasingDelay, and actorRestoreEasingState.

Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite behaviour given by the passed alpha.

See clutter_actor_animate() for further details.

This function is useful if you want to use an existing Alpha 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.

Since: 1.0

animateWithTimelinev

actorAnimateWithTimelinev

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsTimeline b)

=> a

actor: a Actor

-> CULong

mode: an animation mode logical id

-> b

timeline: a Timeline

-> [Text]

properties: a vector containing the property names to set

-> [GValue]

values: a vector containing the property values to set

-> m Animation

Returns: a Animation object. The object is owned by the Actor and should not be unreferenced with objectUnref

Deprecated: (Since version 1.12)Use the implicit transition for animatable properties in Actor instead. See actorSaveEasingState, actorSetEasingMode, actorSetEasingDuration, actorSetEasingDelay, and actorRestoreEasingState.

Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite duration given by timeline and a speed given by the mode.

See clutter_actor_animate() for further details.

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

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

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

Since: 1.0

animatev

actorAnimatev

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

actor: a Actor

-> CULong

mode: an animation mode logical id

-> Word32

duration: duration of the animation, in milliseconds

-> [Text]

properties: a vector containing the property names to set

-> [GValue]

values: a vector containing the property values to set

-> m Animation

Returns: a Animation object. The object is owned by the Actor and should not be unreferenced with objectUnref

Deprecated: (Since version 1.12)Use the implicit transition for animatable properties in Actor instead. See actorSaveEasingState, actorSetEasingMode, actorSetEasingDuration, actorSetEasingDelay, and actorRestoreEasingState.

Animates the given list of properties of actor between the current value for each property and a new final value. The animation has a definite duration and a speed given by the mode.

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

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

Since: 1.0

applyRelativeTransformToPoint

actorApplyRelativeTransformToPoint

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: A Actor

-> Maybe b

ancestor: A Actor ancestor, or Nothing to use the default Stage

-> Vertex

point: A point as Vertex

-> m Vertex

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 Nothing the ancestor will be the Stage. 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 actorApplyTransformToPoint.

Since: 0.6

applyTransformToPoint

actorApplyTransformToPoint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Vertex

point: A point as Vertex

-> m Vertex

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

Since: 0.4

bindModel

actorBindModel

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsListModel b)

=> a

self: a Actor

-> Maybe b

model: a ListModel

-> ActorCreateChildFunc

createChildFunc: a function that creates Actor instances from the contents of the model

-> m ()

Binds a ListModel to a Actor.

If the Actor was already bound to a ListModel, the previous binding is destroyed.

The existing children of Actor are destroyed when setting a model, and new children are created and added, representing the contents of the model. The Actor is updated whenever the model changes. If model is Nothing, the Actor is left empty.

When a Actor is bound to a model, adding and removing children directly is undefined behaviour.

Since: 1.24

clearActions

actorClearActions

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Clears the list of actions applied to self

Since: 1.4

clearConstraints

actorClearConstraints

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Clears the list of constraints applied to self

Since: 1.4

clearEffects

actorClearEffects

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Clears the list of effects applied to self

Since: 1.4

contains

actorContains

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: A Actor

-> b

descendant: A Actor, possibly contained in self

-> m Bool

Returns: whether descendent is contained within self

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.

Since: 1.4

continuePaint

actorContinuePaint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

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.

Since: 1.8

createPangoContext

actorCreatePangoContext

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Context

Returns: the newly created Context. Use objectUnref on the returned value to deallocate its resources

Creates a Context for the given actor. The Context is already configured using the appropriate font map, resolution and font options.

See also actorGetPangoContext.

Since: 1.0

createPangoLayout

actorCreatePangoLayout

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Maybe Text

text: the text to set on the Layout, or Nothing

-> m Layout

Returns: the newly created Layout. Use objectUnref when done

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.

If you want to keep around a Layout created by this function you will have to connect to the fontChanged and resolutionChanged signals, and call layoutContextChanged in response to them.

Since: 1.0

destroy

actorDestroy

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

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 Stage returned by stageGetDefault.

destroyAllChildren

actorDestroyAllChildren

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

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 destroy signal is emitted on each child of the actor.

By default, Actor will emit the destroy signal when its reference count drops to 0; the default handler of the 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 actorRemoveAllChildren which will merely release the reference and remove each child.

Unless you acquired an additional reference on each child of self prior to calling actorRemoveAllChildren and want to reuse the actors, you should use actorDestroyAllChildren 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.

Since: 1.10

detachAnimation

actorDetachAnimation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

actor: a Actor

-> m ()

Deprecated: (Since version 1.12)Use the implicit transition for animatable properties in Actor instead, and actorRemoveTransition to remove the transition.

Detaches the Animation used by actor, if clutter_actor_animate() has been called on actor.

Once the animation has been detached, it loses a reference. If it was the only reference then the Animation becomes invalid.

The completed signal will not be emitted.

Since: 1.4

event

actorEvent

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

actor: a Actor

-> Event

event: a Event

-> Bool

capture: True if event in in capture phase, False otherwise.

-> m Bool

Returns: the return value from the signal emission: True if the actor handled the event, or False if the event was not handled

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

getAccessible

actorGetAccessible

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Object

Returns: the Object associated with actor

Returns the accessible object that describes the actor to an assistive technology.

If no class-specific Object implementation is available for the actor instance in question, it will inherit an Object implementation from the first ancestor class for which such an implementation is defined.

The documentation of the <ulink url="http://developer.gnome.org/doc/API/2.0/atk/index.html">ATK</ulink> library contains more information about accessible objects and their uses.

getAction

actorGetAction

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

name: the name of the action to retrieve

-> m Action

Returns: a Action for the given name, or Nothing. The returned Action is owned by the actor and it should not be unreferenced directly

Retrieves the Action with the given name in the list of actions applied to self

Since: 1.4

getActions

actorGetActions

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m [Action]

Returns: a copy of the list of Actions. The contents of the list are owned by the Actor. Use g_list_free() to free the resources allocated by the returned List

Retrieves the list of actions applied to self

Since: 1.4

getAllocationBox

actorGetAllocationBox

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ActorBox

Gets the layout box an actor has been assigned. The allocation can only be assumed valid inside a paint() method; anywhere else, it may be out-of-date.

An allocation does not incorporate the actor's scale or anchor point; those transformations do not affect layout, only rendering.

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.

Since: 0.8

getAllocationGeometry

actorGetAllocationGeometry

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Geometry

Deprecated: (Since version 1.12)Use actorGetAllocationBox instead.

Gets the layout box an actor has been assigned. The allocation can only be assumed valid inside a paint() method; anywhere else, it may be out-of-date.

An allocation does not incorporate the actor's scale or anchor point; those transformations do not affect layout, only rendering.

The returned rectangle is in pixels.

Since: 0.8

getAnchorPoint

actorGetAnchorPoint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m (Float, Float)

Deprecated: (Since version 1.12)Use Actor:pivot-point instead

Gets the current anchor point of the actor in pixels.

Since: 0.6

getAnchorPointGravity

actorGetAnchorPointGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Gravity

Returns: the Gravity used by the anchor point

Deprecated: (Since version 1.12)Use Actor:pivot-point instead.

Retrieves the anchor position expressed as a Gravity. If the anchor point was specified using pixels or units this will return GravityNone.

Since: 1.0

getAnimation

actorGetAnimation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

actor: a Actor

-> m Animation

Returns: a Animation, or Nothing

Deprecated: (Since version 1.12)Use the implicit transition for animatable properties in Actor instead, and actorGetTransition to retrieve the transition.

Retrieves the Animation used by actor, if clutter_actor_animate() has been called on actor.

Since: 1.0

getBackgroundColor

actorGetBackgroundColor

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Color

Retrieves the color set using actorSetBackgroundColor.

Since: 1.10

getChildAtIndex

actorGetChildAtIndex

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Int32

index_: the position in the list of children

-> m Actor

Returns: a pointer to a Actor, or Nothing

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

Since: 1.10

getChildren

actorGetChildren

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m [Actor]

Returns: A newly allocated List of Actors. Use g_list_free() when done.

Retrieves the list of children of self.

Since: 1.10

getClip

actorGetClip

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m (Float, Float, Float, Float)

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

Since: 0.6

getClipToAllocation

actorGetClipToAllocation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the Actor is clipped to its allocation

Retrieves the value set using actorSetClipToAllocation

Since: 1.4

getConstraint

actorGetConstraint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

name: the name of the constraint to retrieve

-> m Constraint

Returns: a Constraint for the given name, or Nothing. The returned Constraint is owned by the actor and it should not be unreferenced directly

Retrieves the Constraint with the given name in the list of constraints applied to self

Since: 1.4

getConstraints

actorGetConstraints

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m [Constraint]

Returns: a copy of the list of Constraints. The contents of the list are owned by the Actor. Use g_list_free() to free the resources allocated by the returned List

Retrieves the list of constraints applied to self

Since: 1.4

getContent

actorGetContent

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Content

Returns: a pointer to the Content instance, or Nothing if none was set

Retrieves the contents of self.

Since: 1.10

getContentBox

actorGetContentBox

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ActorBox

Retrieves the bounding box for the Content of self.

The bounding box is relative to the actor's allocation.

If no Content 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 Actor.

If the Content used by the actor has a preferred size, then it is possible to modify the content box by using the Actor:content-gravity property.

Since: 1.10

getContentGravity

actorGetContentGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ContentGravity

Returns: the content gravity

Retrieves the content gravity as set using actorSetContentGravity.

Since: 1.10

getContentRepeat

actorGetContentRepeat

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m [ContentRepeat]

Returns: the content repeat policy

Retrieves the repeat policy for a Actor set by actorSetContentRepeat.

Since: 1.12

getContentScalingFilters

actorGetContentScalingFilters

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m (ScalingFilter, ScalingFilter)

Retrieves the values set using actorSetContentScalingFilters.

Since: 1.10

getDefaultPaintVolume

actorGetDefaultPaintVolume

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m PaintVolume

Returns: a pointer to the default PaintVolume, relative to the Actor, or Nothing if the actor could not compute a valid paint volume. The returned value is not guaranteed to be stable across multiple frames, so if you want to retain it, you will need to copy it using paintVolumeCopy.

Retrieves the default paint volume for self.

This function provides the same PaintVolume that would be computed by the default implementation inside Actor of the ActorClass.get_paint_volume() virtual function.

This function should only be used by Actor subclasses that cannot chain up to the parent implementation when computing their paint volume.

Since: 1.10

getDepth

actorGetDepth

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Float

Returns: the depth of the actor

Deprecated: (Since version 1.12)Use actorGetZPosition instead.

Retrieves the depth of self.

getEasingDelay

actorGetEasingDelay

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Word32

Returns: a delay, in milliseconds

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

Since: 1.10

getEasingDuration

actorGetEasingDuration

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Word32

Returns: the duration of the tweening, in milliseconds

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

Since: 1.10

getEasingMode

actorGetEasingMode

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m AnimationMode

Returns: an easing mode

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

Since: 1.10

getEffect

actorGetEffect

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

name: the name of the effect to retrieve

-> m Effect

Returns: a Effect for the given name, or Nothing. The returned Effect is owned by the actor and it should not be unreferenced directly

Retrieves the Effect with the given name in the list of effects applied to self

Since: 1.4

getEffects

actorGetEffects

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m [Effect]

Returns: a list of Effects, or Nothing. 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

Retrieves the Effects applied on self, if any

Since: 1.4

getFirstChild

actorGetFirstChild

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Actor

Returns: a pointer to a Actor, or Nothing

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.

Since: 1.10

getFixedPositionSet

actorGetFixedPositionSet

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Bool

Returns: True if the fixed position is set on the actor

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

Since: 0.8

getFlags

actorGetFlags

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m [ActorFlags]

Returns: a bitwise or of ActorFlags or 0

Retrieves the flags set on self

Since: 1.0

getGeometry

actorGetGeometry

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Geometry

Deprecated: (Since version 1.10)Use actorGetPosition and actorGetSize, or actorGetAllocationGeometry instead.

Gets the size and position of an actor relative to its parent actor. This is the same as calling actorGetPosition and actorGetSize. It tries to "do what you mean" and get the requested size and position if the actor's allocation is invalid.

getGid

actorGetGid

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Word32

Returns: Globally unique value for this object instance.

Deprecated: (Since version 1.8)The id is not used any longer, and this function always returns 0.

Retrieves the unique id for self.

Since: 0.6

getHeight

actorGetHeight

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Float

Returns: the height of the actor, in pixels

Retrieves the height of a Actor.

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 actorGetAllocationBox to retrieve the allocated size or actorGetPreferredHeight to retrieve the preferred height.

If an actor has a fixed height, for instance a height that has been assigned using actorSetHeight, the height returned will be the same value.

getLastChild

actorGetLastChild

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Actor

Returns: a pointer to a Actor, or Nothing

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.

Since: 1.10

getLayoutManager

actorGetLayoutManager

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m LayoutManager

Returns: a pointer to the LayoutManager, or Nothing

Retrieves the LayoutManager used by self.

Since: 1.10

getMargin

actorGetMargin

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Margin

Retrieves all the components of the margin of a Actor.

Since: 1.10

getMarginBottom

actorGetMarginBottom

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Float

Returns: the bottom margin

Retrieves the bottom margin of a Actor.

Since: 1.10

getMarginLeft

actorGetMarginLeft

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Float

Returns: the left margin

Retrieves the left margin of a Actor.

Since: 1.10

getMarginRight

actorGetMarginRight

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Float

Returns: the right margin

Retrieves the right margin of a Actor.

Since: 1.10

getMarginTop

actorGetMarginTop

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Float

Returns: the top margin

Retrieves the top margin of a Actor.

Since: 1.10

getNChildren

actorGetNChildren

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Int32

Returns: the number of children of an actor

Retrieves the number of children of self.

Since: 1.10

getName

actorGetName

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Text

Returns: the name of the actor, or Nothing. The returned string is owned by the actor and should not be modified or freed.

Retrieves the name of self.

getNextSibling

actorGetNextSibling

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Actor

Returns: a pointer to a Actor, or Nothing

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.

Since: 1.10

getOffscreenRedirect

actorGetOffscreenRedirect

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m [OffscreenRedirect]

Returns: the value of the offscreen-redirect property of the actor

Retrieves whether to redirect the actor to an offscreen buffer, as set by actorSetOffscreenRedirect.

Since: 1.8

getOpacity

actorGetOpacity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Word8

Returns: the opacity of the actor

Retrieves the opacity value of an actor, as set by actorSetOpacity.

For retrieving the absolute opacity of the actor inside a paint virtual function, see actorGetPaintOpacity.

getPaintBox

actorGetPaintBox

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m (Bool, ActorBox)

Returns: True if a 2D paint box could be determined, else False.

Retrieves the paint volume of the passed Actor, 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.

Since: 1.6

getPaintOpacity

actorGetPaintOpacity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Word8

Returns: The actor opacity value.

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.

Since: 0.8

getPaintVisibility

actorGetPaintVisibility

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Bool

Returns: True if the actor is visibile and will be painted.

Retrieves the 'paint' visibility of an actor recursively checking for non visible parents.

This is by definition the same as CLUTTER_ACTOR_IS_MAPPED.

Since: 0.8

getPaintVolume

actorGetPaintVolume

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m PaintVolume

Returns: a pointer to a PaintVolume, or Nothing 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 paintVolumeCopy.

Retrieves the paint volume of the passed Actor, or Nothing 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 ActorClass.get_paint_volume() virtual function of the Actor class. Sub-classes of Actor 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 Actor:depth but real 3D depth).

Note: 2D actors overriding ActorClass.get_paint_volume() should ensure that their volume has a depth of 0. (This will be true as long as you don't call paintVolumeSetDepth.)

Since: 1.6

getPangoContext

actorGetPangoContext

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Context

Returns: the Context for a Actor. The returned Context is owned by the actor and should not be unreferenced by the application code

Retrieves the Context for self. The actor's Context is already configured using the appropriate font map, resolution and font options.

Unlike actorCreatePangoContext, this context is owend by the Actor and it will be updated each time the options stored by the Backend change.

You can use the returned Context to create a Layout and render text using renderLayout to reuse the glyphs cache also used by Clutter.

Since: 1.0

getParent

actorGetParent

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Actor

Returns: The Actor parent, or Nothing if no parent is set

Retrieves the parent of self.

getPivotPoint

actorGetPivotPoint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m (Float, Float)

Retrieves the coordinates of the Actor:pivot-point.

Since: 1.12

getPivotPointZ

actorGetPivotPointZ

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Float

Retrieves the Z component of the Actor:pivot-point.

Since: 1.12

getPosition

actorGetPosition

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m (Float, Float)

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.

Since: 0.6

getPreferredHeight

actorGetPreferredHeight

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

forWidth: available width to assume in computing desired height, or a negative value to indicate that no width is defined

-> m (Float, Float)

Computes the requested minimum and natural heights for an actor, or if they are already computed, returns the cached values.

An actor may not get its request - depending on the layout manager that's in effect.

A request should not incorporate the actor's scale or anchor point; those transformations do not affect layout, only rendering.

Since: 0.8

getPreferredSize

actorGetPreferredSize

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m (Float, Float, Float, Float)

Computes the preferred minimum and natural size of an actor, taking into account the actor's geometry management (either height-for-width or width-for-height).

The width and height used to compute the preferred height and preferred width are the actor's natural ones.

If you need to control the height for the preferred width, or the width for the preferred height, you should use actorGetPreferredWidth and actorGetPreferredHeight, and check the actor's preferred geometry management using the Actor:request-mode property.

Since: 0.8

getPreferredWidth

actorGetPreferredWidth

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

forHeight: available height when computing the preferred width, or a negative value to indicate that no height is defined

-> m (Float, Float)

Computes the requested minimum and natural widths for an actor, optionally depending on the specified height, or if they are already computed, returns the cached values.

An actor may not get its request - depending on the layout manager that's in effect.

A request should not incorporate the actor's scale or anchor point; those transformations do not affect layout, only rendering.

Since: 0.8

getPreviousSibling

actorGetPreviousSibling

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Actor

Returns: a pointer to a Actor, or Nothing

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.

Since: 1.10

getReactive

actorGetReactive

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

actor: a Actor

-> m Bool

Returns: True if the actor is reactive

Checks whether actor is marked as reactive.

Since: 0.6

getRequestMode

actorGetRequestMode

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m RequestMode

Returns: the request mode for the actor

Retrieves the geometry request mode of self

Since: 1.2

getRotation

actorGetRotation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> RotateAxis

axis: the axis of rotation

-> m (Double, Float, Float, Float)

Returns: the angle of rotation

Deprecated: (Since version 1.12)Use actorGetRotationAngle and actorGetPivotPoint instead.

Retrieves the angle and center of rotation on the given axis, set using actorSetRotation.

Since: 0.8

getRotationAngle

actorGetRotationAngle

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> RotateAxis

axis: the axis of the rotation

-> m Double

Returns: the angle of rotation, in degrees

Retrieves the angle of rotation set by actorSetRotationAngle.

Since: 1.12

getScale

actorGetScale

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m (Double, Double)

Retrieves an actors scale factors.

Since: 0.2

getScaleCenter

actorGetScaleCenter

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m (Float, Float)

Deprecated: (Since version 1.12)Use actorGetPivotPoint instead.

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.

Since: 1.0

getScaleGravity

actorGetScaleGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Gravity

Returns: the scale gravity

Deprecated: (Since version 1.12)Use actorGetPivotPoint instead.

Retrieves the scale center as a compass direction. If the scale center was specified in pixels or units this will return GravityNone.

Since: 1.0

getScaleZ

actorGetScaleZ

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Double

Returns: the scaling factor along the Z axis

Retrieves the scaling factor along the Z axis, as set using actorSetScaleZ.

Since: 1.12

getShader

actorGetShader

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Shader

Returns: The currently set Shader or Nothing if no shader is set.

Deprecated: (Since version 1.8)Use actorGetEffect instead.

Queries the currently set Shader on self.

Since: 0.6

getSize

actorGetSize

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m (Float, Float)

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 actorGetAllocationBox or actorGetPreferredWidth.

Since: 0.2

getStage

actorGetStage

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

actor: a Actor

-> m Stage

Returns: the stage containing the actor, or Nothing

Retrieves the Stage where actor is contained.

Since: 0.8

getTextDirection

actorGetTextDirection

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m TextDirection

Returns: the TextDirection for the actor

Retrieves the value set using actorSetTextDirection

If no text direction has been previously set, the default text direction, as returned by getDefaultTextDirection, will be returned instead

Since: 1.2

getTransformedPaintVolume

actorGetTransformedPaintVolume

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: a Actor

-> b

relativeToAncestor: A Actor that is an ancestor of self (or Nothing for the stage)

-> m PaintVolume

Returns: a pointer to a PaintVolume, or Nothing if no volume could be determined. The returned pointer is not guaranteed to be valid across multiple frames; if you wish to keep it, you will have to copy it using paintVolumeCopy.

Retrieves the 3D paint volume of an actor like actorGetPaintVolume does (Please refer to the documentation of actorGetPaintVolume for more details.) and it additionally transforms the paint volume into the coordinate space of relativeToAncestor. (Or the stage if Nothing is passed for relativeToAncestor)

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 paintVolumeUnion.

Since: 1.6

getTransformedPosition

actorGetTransformedPosition

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m (Float, Float)

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

Since: 0.8

getTransformedSize

actorGetTransformedSize

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m (Float, Float)

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 actorGetAbsAllocationVertices 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 actorGetTransformedPosition; if you need this information, you need to use actorGetAbsAllocationVertices to get the coords of the actual quadrangle.

Since: 0.8

getTransition

actorGetTransition

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

name: the name of the transition

-> m Transition

Returns: a Transition, or Nothing is none was found to match the passed name; the returned instance is owned by Clutter and it should not be freed

Retrieves the Transition of a Actor by using the transition name.

Transitions created for animatable properties use the name of the property itself, for instance the code below:

C code

 clutter_actor_set_easing_duration (actor, 1000);
 clutter_actor_set_rotation (actor, CLUTTER_Y_AXIS, 360.0, x, y, z);

 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 transitionStopped signal, using the transition name as the signal detail.

Since: 1.10

getTranslation

actorGetTranslation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m (Float, Float, Float)

Retrieves the translation set using actorSetTranslation.

Since: 1.12

getWidth

actorGetWidth

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Float

Returns: the width of the actor, in pixels

Retrieves the width of a Actor.

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 actorGetAllocationBox to retrieve the allocated size or actorGetPreferredWidth to retrieve the preferred width.

If an actor has a fixed width, for instance a width that has been assigned using actorSetWidth, the width returned will be the same value.

getX

actorGetX

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Float

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

Retrieves the X coordinate of a Actor.

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 actorSetX, actorSetPosition or actorSetGeometry, this function will return that coordinate.

If both the allocation and a fixed position are missing, this function will return 0.

getXAlign

actorGetXAlign

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ActorAlign

Returns: the horizontal alignment policy.

Retrieves the horizontal alignment policy set using actorSetXAlign.

Since: 1.10

getXExpand

actorGetXExpand

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor has been set to expand

Retrieves the value set with actorSetXExpand.

See also: actorNeedsExpand

Since: 1.12

getY

actorGetY

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Float

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

Retrieves the Y coordinate of a Actor.

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 actorSetY, actorSetPosition or actorSetGeometry, this function will return that coordinate.

If both the allocation and a fixed position are missing, this function will return 0.

getYAlign

actorGetYAlign

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ActorAlign

Returns: the vertical alignment policy.

Retrieves the vertical alignment policy set using actorSetYAlign.

Since: 1.10

getYExpand

actorGetYExpand

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor has been set to expand

Retrieves the value set with actorSetYExpand.

See also: actorNeedsExpand

Since: 1.12

getZPosition

actorGetZPosition

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Float

Returns: the position on the Z axis.

Retrieves the actor's position on the Z axis.

Since: 1.12

getZRotationGravity

actorGetZRotationGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Gravity

Returns: the Z rotation center

Deprecated: (Since version 1.12)Use the Actor:pivot-point instead of a 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 GravityNone.

Since: 1.0

grabKeyFocus

actorGrabKeyFocus

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Sets the key focus of the Stage including self to this Actor.

Since: 1.0

hasActions

actorHasActions

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Bool

Returns: True if the actor has any actions, False otherwise

Returns whether the actor has any actions applied.

Since: 1.10

hasAllocation

actorHasAllocation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor has an up-to-date 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).

If this function returns False, then the actor will normally be allocated before it is next drawn on the screen.

Since: 1.4

hasClip

actorHasClip

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor has a clip area set.

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

Since: 0.2

hasConstraints

actorHasConstraints

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Bool

Returns: True if the actor has any constraints, False otherwise

Returns whether the actor has any constraints applied.

Since: 1.10

hasEffects

actorHasEffects

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Bool

Returns: True if the actor has any effects, False otherwise

Returns whether the actor has any effects applied.

Since: 1.10

hasKeyFocus

actorHasKeyFocus

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor has key focus, and False otherwise

Checks whether self is the Actor that has key focus

Since: 1.4

hasOverlaps

actorHasOverlaps

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Bool

Returns: True if the actor may have overlapping primitives, and False otherwise

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 ActorClass.has_overlaps() virtual function. See actorSetOffscreenRedirect for more information.

Since: 1.8

hasPointer

actorHasPointer

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor contains the pointer, and False otherwise

Checks whether an actor contains the pointer of a InputDevice

Since: 1.2

hide

actorHide

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

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 Actor:show-on-set-parent property will be set to False as a side-effect.

hideAll

actorHideAll

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Deprecated: (Since version 1.10)Using actorHide on the actor will prevent its children from being painted as well.

Calls actorHide on all child actors (if any).

Since: 0.2

insertChildAbove

actorInsertChildAbove

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c)

=> a

self: a Actor

-> b

child: a Actor

-> Maybe c

sibling: a child of self, or Nothing

-> m ()

Inserts child into the list of children of self, above another child of self or, if sibling is Nothing, above all the children of self.

This function will acquire a reference on child that will only be released when calling actorRemoveChild.

This function will not take into consideration the Actor:depth of child.

This function will emit the actorAdded signal on self.

Since: 1.10

insertChildAtIndex

actorInsertChildAtIndex

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: a Actor

-> b

child: a Actor

-> Int32

index_: the index

-> m ()

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 actorRemoveChild.

This function will not take into consideration the Actor:depth of child.

This function will emit the actorAdded signal on self.

Since: 1.10

insertChildBelow

actorInsertChildBelow

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c)

=> a

self: a Actor

-> b

child: a Actor

-> Maybe c

sibling: a child of self, or Nothing

-> m ()

Inserts child into the list of children of self, below another child of self or, if sibling is Nothing, below all the children of self.

This function will acquire a reference on child that will only be released when calling actorRemoveChild.

This function will not take into consideration the Actor:depth of child.

This function will emit the actorAdded signal on self.

Since: 1.10

isInClonePaint

actorIsInClonePaint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the Actor is currently being painted by a Clone, and False otherwise

Checks whether self is being currently painted by a Clone

This function is useful only inside the paint virtual function implementations or within handlers for the paint signal

This function should not be used by applications

Since: 1.0

isMapped

actorIsMapped

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor is mapped

Checks whether a Actor has been set as mapped.

See also CLUTTER_ACTOR_IS_MAPPED and Actor:mapped

Since: 1.24

isRealized

actorIsRealized

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor is realized

Checks whether a Actor is realized.

See also CLUTTER_ACTOR_IS_REALIZED and Actor:realized.

Since: 1.24

isRotated

actorIsRotated

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor is rotated.

Checks whether any rotation is applied to the actor.

Since: 0.6

isScaled

actorIsScaled

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor is scaled.

Checks whether the actor is scaled in either dimension.

Since: 0.6

isVisible

actorIsVisible

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m Bool

Returns: True if the actor visible

Checks whether an actor is marked as visible.

See also CLUTTER_ACTOR_IS_VISIBLE and Actor:visible.

Since: 1.24

lower

actorLower

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: A Actor

-> Maybe b

above: A Actor to lower below

-> m ()

Deprecated: (Since version 1.10)Use actorSetChildBelowSibling instead.

Puts self below above.

Both actors must have the same parent, and the parent must implement the Container interface.

This function calls containerLowerChild internally.

lowerBottom

actorLowerBottom

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Deprecated: (Since version 1.10)Use actorSetChildBelowSibling with a Nothing sibling, instead.

Lowers self to the bottom.

This function calls actorLower internally.

map

actorMap

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Sets the ActorFlagsMapped 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 disencouraged: the default implementation of ActorClass.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.

Since: 1.0

moveAnchorPoint

actorMoveAnchorPoint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

anchorX: X coordinate of the anchor point

-> Float

anchorY: Y coordinate of the anchor point

-> m ()

Deprecated: (Since version 1.12)Use Actor:pivot-point andactorSetTranslation instead.

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.

Since: 0.6

moveAnchorPointFromGravity

actorMoveAnchorPointFromGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Gravity

gravity: Gravity.

-> m ()

Deprecated: (Since version 1.12)Use Actor:pivot-point andactorSetTranslation instead.

Sets an anchor point on the actor based on the given gravity, adjusting the actor postion so that its relative position within its parent remains unchanged.

Since version 1.0 the anchor point will be stored as a gravity so that if the actor changes size then the anchor point will move. For example, if you set the anchor point to GravitySouthEast and later double the size of the actor, the anchor point will move to the bottom right.

Since: 0.6

moveBy

actorMoveBy

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

dx: Distance to move Actor on X axis.

-> Float

dy: Distance to move Actor on Y axis.

-> m ()

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

This function modifies the fixed position of an actor and thus removes it from any layout management. Another way to move an actor is with an anchor point, see actorSetAnchorPoint, or with an additional translation, using actorSetTranslation.

Since: 0.2

needsExpand

actorNeedsExpand

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Orientation

orientation: the direction of expansion

-> m Bool

Returns: True if the actor should expand

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 actorGetXExpand or actorGetYExpand.

Since: 1.12

new

actorNew

Arguments

:: (HasCallStack, MonadIO m)

=> m Actor

Returns: the newly created Actor

Creates a new Actor.

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

Since: 1.10

paint

actorPaint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Renders the actor to display.

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

This function is context-aware, and will either cause a regular paint or a pick paint.

This function will emit the paint signal or the pick signal, depending on the context.

This function does not paint the actor if the actor is set to 0, unless it is performing a pick paint.

popInternal

actorPopInternal

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Deprecated: (Since version 1.10)All children of an actor are accessible through the Actor API. This function is only useful for legacy containers overriding the default implementation of the Container interface.

Disables the effects of actorPushInternal.

Since: 1.2

pushInternal

actorPushInternal

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Deprecated: (Since version 1.10)All children of an actor are accessible through the Actor API, and Actor implements the Container interface, so this function is only useful for legacy containers overriding the default implementation.

Should be used by actors implementing the Container and with internal children added through actorSetParent, for instance:

C code

 static void
 my_actor_init (MyActor *self)
 {
   self->priv = my_actor_get_instance_private (self);

   clutter_actor_push_internal (CLUTTER_ACTOR (self));

   // calling clutter_actor_set_parent() now will result in
   // the internal flag being set on a child of MyActor

   // internal child - a background texture
   self->priv->background_tex = clutter_texture_new ();
   clutter_actor_set_parent (self->priv->background_tex,
                             CLUTTER_ACTOR (self));

   // internal child - a label
   self->priv->label = clutter_text_new ();
   clutter_actor_set_parent (self->priv->label,
                             CLUTTER_ACTOR (self));

   clutter_actor_pop_internal (CLUTTER_ACTOR (self));

   // calling clutter_actor_set_parent() now will not result in
   // the internal flag being set on a child of MyActor
 }

This function will be used by Clutter to toggle an "internal child" flag whenever actorSetParent is called; internal children are handled differently by Clutter, specifically when destroying their parent.

Call actorPopInternal when you finished adding internal children.

Nested calls to actorPushInternal are allowed, but each one must by followed by a actorPopInternal call.

Since: 1.2

queueRedraw

actorQueueRedraw

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

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.

queueRedrawWithClip

actorQueueRedrawWithClip

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Maybe RectangleInt

clip: a rectangular clip region, or Nothing

-> m ()

Queues a redraw on self limited to a specific, actor-relative rectangular area.

If clip is Nothing this function is equivalent to actorQueueRedraw.

Since: 1.10

queueRelayout

actorQueueRelayout

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Indicates that the actor's size request or other layout-affecting properties may have changed. This function is used inside Actor subclass implementations, not by applications directly.

Queueing a new layout automatically queues a redraw as well.

Since: 0.8

raise

actorRaise

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: A Actor

-> Maybe b

below: A Actor to raise above.

-> m ()

Deprecated: (Since version 1.10)Use actorSetChildAboveSibling instead.

Puts self above below.

Both actors must have the same parent, and the parent must implement the Container interface

This function calls containerRaiseChild internally.

raiseTop

actorRaiseTop

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Deprecated: (Since version 1.10)Use actorSetChildAboveSibling with a Nothing sibling, instead.

Raises self to the top.

This function calls actorRaise internally.

realize

actorRealize

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Deprecated: (Since version 1.16)Actors are automatically realized, and nothing requires explicit realization.

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 actorRealize 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.

removeAction

actorRemoveAction

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsAction b)

=> a

self: a Actor

-> b

action: a Action

-> m ()

Removes action from the list of actions applied to self

The reference held by self on the Action will be released

Since: 1.4

removeActionByName

actorRemoveActionByName

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

name: the name of the action to remove

-> m ()

Removes the Action with the given name from the list of actions applied to self

Since: 1.4

removeAllChildren

actorRemoveAllChildren

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

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 actorDestroyAllChildren.

Since: 1.10

removeAllTransitions

actorRemoveAllTransitions

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Removes all transitions associated to self.

Since: 1.10

removeChild

actorRemoveChild

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: a Actor

-> b

child: a Actor

-> m ()

Removes child from the children of self.

This function will release the reference added by actorAddChild, 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 actorRemoved signal on self.

Since: 1.10

removeClip

actorRemoveClip

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Removes clip area from self.

removeConstraint

actorRemoveConstraint

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsConstraint b)

=> a

self: a Actor

-> b

constraint: a Constraint

-> m ()

Removes constraint from the list of constraints applied to self

The reference held by self on the Constraint will be released

Since: 1.4

removeConstraintByName

actorRemoveConstraintByName

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

name: the name of the constraint to remove

-> m ()

Removes the Constraint with the given name from the list of constraints applied to self

Since: 1.4

removeEffect

actorRemoveEffect

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsEffect b)

=> a

self: a Actor

-> b

effect: a Effect

-> m ()

Removes effect from the list of effects applied to self

The reference held by self on the Effect will be released

Since: 1.4

removeEffectByName

actorRemoveEffectByName

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

name: the name of the effect to remove

-> m ()

Removes the Effect with the given name from the list of effects applied to self

Since: 1.4

removeTransition

actorRemoveTransition

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

name: the name of the transition to remove

-> m ()

Removes the transition stored inside a Actor 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 Actor.

Since: 1.10

reparent

actorReparent

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: a Actor

-> b

newParent: the new Actor parent

-> m ()

Deprecated: (Since version 1.10)Use actorRemoveChild and actorAddChild instead; remember to take a reference on the actor being removed before calling actorRemoveChild to avoid the reference count dropping to zero and the actor being destroyed.

Resets the parent actor of self.

This function is logically equivalent to calling actorUnparent and actorSetParent, but more efficiently implemented, as it ensures the child is not finalized when unparented, and emits the parentSet signal only once.

In reality, calling this function is less useful than it sounds, as some application code may rely on changes in the intermediate state between removal and addition of the actor from its old parent to the newParent. Thus, it is strongly encouraged to avoid using this function in application code.

Since: 0.2

replaceChild

actorReplaceChild

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c)

=> a

self: a Actor

-> b

oldChild: the child of self to replace

-> c

newChild: the Actor to replace oldChild

-> m ()

Replaces oldChild with newChild in the list of children of self.

Since: 1.10

restoreEasingState

actorRestoreEasingState

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Restores the easing state as it was prior to a call to actorSaveEasingState.

Since: 1.10

saveEasingState

actorSaveEasingState

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

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.

Since: 1.10

setAllocation

actorSetAllocation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> ActorBox

box: a ActorBox

-> [AllocationFlags]

flags: allocation flags

-> m ()

Stores the allocation of self as defined by box.

This function can only be called from within the implementation of the ActorClass.allocate() virtual function.

The allocation should have been adjusted to take into account constraints, alignment, and margin properties. If you are implementing a Actor subclass that provides its own layout management policy for its children instead of using a LayoutManager delegate, you should not call this function on the children of self; instead, you should call actorAllocate, which will adjust the allocation box for you.

This function should only be used by subclasses of Actor that wish to store their allocation but cannot chain up to the parent's implementation; the default implementation of the ActorClass.allocate() virtual function will call this function.

It is important to note that, while chaining up was the recommended behaviour for Actor subclasses prior to the introduction of this function, it is recommended to call actorSetAllocation instead.

If the Actor is using a LayoutManager delegate object to handle the allocation of its children, this function will call the layoutManagerAllocate function only if the AllocationFlagsDelegateLayout flag is set on flags, otherwise it is expected that the subclass will call layoutManagerAllocate by itself. For instance, the following code:

C code

static void
my_actor_allocate (ClutterActor *actor,
                   const ClutterActorBox *allocation,
                   ClutterAllocationFlags flags)
{
  ClutterActorBox new_alloc;
  ClutterAllocationFlags new_flags;

  adjust_allocation (allocation, &new_alloc);

  new_flags = flags | CLUTTER_DELEGATE_LAYOUT;

  // this will use the layout manager set on the actor
  clutter_actor_set_allocation (actor, &new_alloc, new_flags);
}

is equivalent to this:

C code

static void
my_actor_allocate (ClutterActor *actor,
                   const ClutterActorBox *allocation,
                   ClutterAllocationFlags flags)
{
  ClutterLayoutManager *layout;
  ClutterActorBox new_alloc;

  adjust_allocation (allocation, &new_alloc);

  clutter_actor_set_allocation (actor, &new_alloc, flags);

  layout = clutter_actor_get_layout_manager (actor);
  clutter_layout_manager_allocate (layout,
                                   CLUTTER_CONTAINER (actor),
                                   &new_alloc,
                                   flags);
}

Since: 1.10

setAnchorPoint

actorSetAnchorPoint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

anchorX: X coordinate of the anchor point

-> Float

anchorY: Y coordinate of the anchor point

-> m ()

Deprecated: (Since version 1.12)Use Actor:pivot-point instead.

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.

Since: 0.6

setAnchorPointFromGravity

actorSetAnchorPointFromGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Gravity

gravity: Gravity.

-> m ()

Deprecated: (Since version 1.12)Use Actor:pivot-point andactorSetTranslation instead. E.g. For GravityCenter setpivot_point to (0.5,0.5) and the translation to (width/2,height/2).

Sets an anchor point on the actor, based on the given gravity (this is a convenience function wrapping actorSetAnchorPoint).

Since version 1.0 the anchor point will be stored as a gravity so that if the actor changes size then the anchor point will move. For example, if you set the anchor point to GravitySouthEast and later double the size of the actor, the anchor point will move to the bottom right.

Since: 0.6

setBackgroundColor

actorSetBackgroundColor

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Maybe Color

color: a Color, or Nothing to unset a previously set color

-> m ()

Sets the background color of a Actor.

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 Actor:background-color-set actor property.

The Actor:background-color property is animatable.

Since: 1.10

setChildAboveSibling

actorSetChildAboveSibling

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c)

=> a

self: a Actor

-> b

child: a Actor child of self

-> Maybe c

sibling: a Actor child of self, or Nothing

-> m ()

Sets child to be above sibling in the list of children of self.

If sibling is Nothing, child will be the new last child of self.

This function is logically equivalent to removing child and using actorInsertChildAbove, but it will not emit signals or change state on child.

Since: 1.10

setChildAtIndex

actorSetChildAtIndex

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: a Actor

-> b

child: a Actor child of self

-> Int32

index_: the new index for child

-> m ()

Changes the index of child in the list of children of self.

This function is logically equivalent to removing child and calling actorInsertChildAtIndex, but it will not emit signals or change state on child.

Since: 1.10

setChildBelowSibling

actorSetChildBelowSibling

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c)

=> a

self: a Actor

-> b

child: a Actor child of self

-> Maybe c

sibling: a Actor child of self, or Nothing

-> m ()

Sets child to be below sibling in the list of children of self.

If sibling is Nothing, child will be the new first child of self.

This function is logically equivalent to removing self and using actorInsertChildBelow, but it will not emit signals or change state on child.

Since: 1.10

setChildTransform

actorSetChildTransform

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Maybe Matrix

transform: a Matrix, or Nothing

-> m ()

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 Nothing, the child transform will be unset.

The Actor:child-transform property is animatable.

Since: 1.12

setClip

actorSetClip

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

xoff: X offset of the clip rectangle

-> Float

yoff: Y offset of the clip rectangle

-> Float

width: Width of the clip rectangle

-> Float

height: Height of the clip rectangle

-> m ()

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.

Since: 0.6

setClipToAllocation

actorSetClipToAllocation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Bool

clipSet: True to apply a clip tracking the allocation

-> m ()

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

Since: 1.4

setContent

actorSetContent

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsContent b)

=> a

self: a Actor

-> Maybe b

content: a Content, or Nothing

-> m ()

Sets the contents of a Actor.

Since: 1.10

setContentGravity

actorSetContentGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> ContentGravity

gravity: the ContentGravity

-> m ()

Sets the gravity of the Content used by self.

See the description of the Actor:content-gravity property for more information.

The Actor:content-gravity property is animatable.

Since: 1.10

setContentRepeat

actorSetContentRepeat

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> [ContentRepeat]

repeat: the repeat policy

-> m ()

Sets the policy for repeating the Actor:content of a Actor. The behaviour is deferred to the Content implementation.

Since: 1.12

setContentScalingFilters

actorSetContentScalingFilters

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> ScalingFilter

minFilter: the minification filter for the content

-> ScalingFilter

magFilter: the magnification filter for the content

-> m ()

Sets the minification and magnification filter to be applied when scaling the Actor:content of a Actor.

The Actor:minification-filter will be used when reducing the size of the content; the Actor:magnification-filter will be used when increasing the size of the content.

Since: 1.10

setDepth

actorSetDepth

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

depth: Z co-ord

-> m ()

Deprecated: (Since version 1.12)Use actorSetZPosition instead.

Sets the Z coordinate of self to depth.

The unit used by depth is dependant on the perspective setup. See also stageSetPerspective.

setEasingDelay

actorSetEasingDelay

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Word32

msecs: the delay before the start of the tweening, in milliseconds

-> m ()

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

Since: 1.10

setEasingDuration

actorSetEasingDuration

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Word32

msecs: the duration of the easing, or Nothing

-> m ()

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

Since: 1.10

setEasingMode

actorSetEasingMode

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> AnimationMode

mode: an easing mode, excluding AnimationModeCustomMode

-> m ()

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

Since: 1.10

setFixedPositionSet

actorSetFixedPositionSet

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Bool

isSet: whether to use fixed position

-> m ()

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

Since: 0.8

setFlags

actorSetFlags

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> [ActorFlags]

flags: the flags to set

-> m ()

Sets flags on self

This function will emit notifications for the changed properties

Since: 1.0

setGeometry

actorSetGeometry

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Geometry

geometry: A Geometry

-> m ()

Deprecated: (Since version 1.10)Use actorSetPosition and actorSetSize instead.

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 actorSetPosition and actorSetSize.

setHeight

actorSetHeight

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

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

-> m ()

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.

Since: 0.2

setLayoutManager

actorSetLayoutManager

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsLayoutManager b)

=> a

self: a Actor

-> Maybe b

manager: a LayoutManager, or Nothing to unset it

-> m ()

Sets the LayoutManager delegate object that will be used to lay out the children of self.

The Actor 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.

Since: 1.10

setMargin

actorSetMargin

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Margin

margin: a Margin

-> m ()

Sets all the components of the margin of a Actor.

Since: 1.10

setMarginBottom

actorSetMarginBottom

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

margin: the bottom margin

-> m ()

Sets the margin from the bottom of a Actor.

The Actor:margin-bottom property is animatable.

Since: 1.10

setMarginLeft

actorSetMarginLeft

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

margin: the left margin

-> m ()

Sets the margin from the left of a Actor.

The Actor:margin-left property is animatable.

Since: 1.10

setMarginRight

actorSetMarginRight

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

margin: the right margin

-> m ()

Sets the margin from the right of a Actor.

The Actor:margin-right property is animatable.

Since: 1.10

setMarginTop

actorSetMarginTop

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

margin: the top margin

-> m ()

Sets the margin from the top of a Actor.

The Actor:margin-top property is animatable.

Since: 1.10

setName

actorSetName

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Text

name: Textual tag to apply to actor

-> m ()

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

setOffscreenRedirect

actorSetOffscreenRedirect

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> [OffscreenRedirect]

redirect: New offscreen redirect flags for the actor.

-> m ()

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 Texture) 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 OffscreenRedirectAutomaticForOpacity 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.

Since: 1.8

setOpacity

actorSetOpacity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Word8

opacity: New opacity value for the actor.

-> m ()

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

The Actor:opacity property is animatable.

setParent

actorSetParent

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsActor b)

=> a

self: A Actor

-> b

parent: A new Actor parent

-> m ()

Deprecated: (Since version 1.10)Use actorAddChild instead.

Sets the parent of self to parent.

This function will result in parent acquiring a reference on self, eventually by sinking its floating reference first. The reference will be released by actorUnparent.

This function should only be called by legacy Actors implementing the Container interface.

setPivotPoint

actorSetPivotPoint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

pivotX: the normalized X coordinate of the pivot point

-> Float

pivotY: the normalized Y coordinate of the pivot point

-> m ()

Sets the position of the 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.

Since: 1.12

setPivotPointZ

actorSetPivotPointZ

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

pivotZ: the Z coordinate of the actor's pivot point

-> m ()

Sets the component on the Z axis of the Actor:pivot-point around which the scaling and rotation transformations occur.

The pivotZ value is expressed as a distance along the Z axis.

Since: 1.12

setPosition

actorSetPosition

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

x: New left position of actor in pixels.

-> Float

y: New top position of actor in pixels.

-> m ()

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.

setReactive

actorSetReactive

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

actor: a Actor

-> Bool

reactive: whether the actor should be reactive to events

-> m ()

Sets actor as reactive. Reactive actors will receive events.

Since: 0.6

setRequestMode

actorSetRequestMode

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> RequestMode

mode: the request mode

-> m ()

Sets the geometry request mode of self.

The mode determines the order for invoking actorGetPreferredWidth and actorGetPreferredHeight

Since: 1.2

setRotation

actorSetRotation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> RotateAxis

axis: the axis of rotation

-> Double

angle: the angle of rotation

-> Float

x: X coordinate of the rotation center

-> Float

y: Y coordinate of the rotation center

-> Float

z: Z coordinate of the rotation center

-> m ()

Deprecated: (Since version 1.12)Use actorSetRotationAngle and actorSetPivotPoint instead.

Sets the rotation angle of self around the given axis.

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

• RotateAxisXAxis requires y and z
• RotateAxisYAxis requires x and z
• RotateAxisZAxis requires x and y

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

Since: 0.8

setRotationAngle

actorSetRotationAngle

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> RotateAxis

axis: the axis to set the angle one

-> Double

angle: the angle of rotation, in degrees

-> m ()

Sets the angle of rotation of a Actor on the given axis.

This function is a convenience for setting the rotation properties Actor:rotation-angle-x, Actor:rotation-angle-y, and Actor:rotation-angle-z.

The center of rotation is established by the Actor:pivot-point property.

Since: 1.12

setScale

actorSetScale

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Double

scaleX: double factor to scale actor by horizontally.

-> Double

scaleY: double factor to scale actor by vertically.

-> m ()

Scales an actor with the given factors.

The scale transformation is relative the the Actor:pivot-point.

The Actor:scale-x and Actor:scale-y properties are animatable.

Since: 0.2

setScaleFull

actorSetScaleFull

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Double

scaleX: double factor to scale actor by horizontally.

-> Double

scaleY: double factor to scale actor by vertically.

-> Float

centerX: X coordinate of the center of the scaling

-> Float

centerY: Y coordinate of the center of the scaling

-> m ()

Deprecated: (Since version 1.12)Use actorSetPivotPoint to control the scale center

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

The Actor:scale-x and Actor:scale-y properties are animatable.

Since: 1.0

setScaleWithGravity

actorSetScaleWithGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Double

scaleX: double factor to scale actor by horizontally.

-> Double

scaleY: double factor to scale actor by vertically.

-> Gravity

gravity: the location of the scale center expressed as a compass direction.

-> m ()

Deprecated: (Since version 1.12)Use actorSetPivotPoint to set the scale center using normalized coordinates instead.

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.

The Actor:scale-x and Actor:scale-y properties are animatable.

Since: 1.0

setScaleZ

actorSetScaleZ

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Double

scaleZ: the scaling factor along the Z axis

-> m ()

Scales an actor on the Z axis by the given scaleZ factor.

The scale transformation is relative the the Actor:pivot-point.

The Actor:scale-z property is animatable.

Since: 1.12

setShader

actorSetShader

Arguments

:: (HasCallStack, MonadIO m, IsActor a, IsShader b)

=> a

self: a Actor

-> Maybe b

shader: a Shader or Nothing to unset the shader.

-> m Bool

Returns: True if the shader was successfully applied or removed

Deprecated: (Since version 1.8)Use ShaderEffect and actorAddEffect instead.

Sets the Shader to be used when rendering self.

If shader is Nothing this function will unset any currently set shader for the actor.

Any Effect applied to self will take the precedence over the Shader set using this function.

Since: 0.6

setShaderParam

actorSetShaderParam

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

param: the name of the parameter

-> GValue

value: the value of the parameter

-> m ()

Deprecated: (Since version 1.8)Use shaderEffectSetUniformValue instead

Sets the value for a named parameter of the shader applied to actor.

Since: 1.0

setShaderParamFloat

actorSetShaderParamFloat

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

param: the name of the parameter

-> Float

value: the value of the parameter

-> m ()

Deprecated: (Since version 1.8)Use clutter_shader_effect_set_uniform() instead

Sets the value for a named float parameter of the shader applied to actor.

Since: 0.8

setShaderParamInt

actorSetShaderParamInt

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Text

param: the name of the parameter

-> Int32

value: the value of the parameter

-> m ()

Deprecated: (Since version 1.8)Use clutter_shader_effect_set_uniform() instead

Sets the value for a named int parameter of the shader applied to actor.

Since: 0.8

setSize

actorSetSize

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

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

-> Float

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

-> m ()

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.

setTextDirection

actorSetTextDirection

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> TextDirection

textDir: the text direction for self

-> m ()

Sets the TextDirection for an actor

The passed text direction must not be TextDirectionDefault

If self implements Container then this function will recurse inside all the children of self (including the internal ones).

Composite actors not implementing Container, or actors requiring special handling when the text direction changes, should connect to the notify signal for the Actor:text-direction property

Since: 1.2

setTransform

actorSetTransform

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Maybe Matrix

transform: a Matrix, or Nothing to unset a custom transformation

-> m ()

Overrides the transformations of a Actor 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 Actor:transform property is animatable.

Since: 1.12

setTranslation

actorSetTranslation

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

translateX: the translation along the X axis

-> Float

translateY: the translation along the Y axis

-> Float

translateZ: the translation along the Z axis

-> m ()

Sets an additional translation transformation on a Actor, relative to the Actor:pivot-point.

Since: 1.12

setWidth

actorSetWidth

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

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

-> m ()

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.

Since: 0.2

setX

actorSetX

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

x: the actor's position on the X axis

-> m ()

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

Overrides any layout manager and forces a fixed position for the actor.

The Actor:x property is animatable.

Since: 0.6

setXAlign

actorSetXAlign

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> ActorAlign

xAlign: the horizontal alignment policy

-> m ()

Sets the horizontal alignment policy of a Actor, in case the actor received extra horizontal space.

See also the Actor:x-align property.

Since: 1.10

setXExpand

actorSetXExpand

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Bool

expand: whether the actor should expand horizontally

-> m ()

Sets whether a Actor 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.

Since: 1.12

setY

actorSetY

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

y: the actor's position on the Y axis

-> m ()

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

Overrides any layout manager and forces a fixed position for the actor.

The Actor:y property is animatable.

Since: 0.6

setYAlign

actorSetYAlign

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> ActorAlign

yAlign: the vertical alignment policy

-> m ()

Sets the vertical alignment policy of a Actor, in case the actor received extra vertical space.

See also the Actor:y-align property.

Since: 1.10

setYExpand

actorSetYExpand

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Bool

expand: whether the actor should expand vertically

-> m ()

Sets whether a Actor 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.

Since: 1.12

setZPosition

actorSetZPosition

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Float

zPosition: the position on the Z axis

-> m ()

Sets the actor's position on the Z axis.

See Actor:z-position.

Since: 1.12

setZRotationFromGravity

actorSetZRotationFromGravity

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> Double

angle: the angle of rotation

-> Gravity

gravity: the center point of the rotation

-> m ()

Deprecated: (Since version 1.12)Use actorSetRotationAngle and actorSetPivotPoint instead.

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 GravityCenter. If the actor changes size the center point will move accordingly.

Since: 1.0

shouldPickPaint

actorShouldPickPaint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m Bool

Returns: True if the actor should paint its silhouette, False otherwise

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.

This function should never be called directly by applications.

show

actorShow

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

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 Actor:show-on-set-parent will be set to True as a side effect.

showAll

actorShowAll

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Deprecated: (Since version 1.10)Actors are visible by default

Calls actorShow on all children of an actor (if any).

Since: 0.2

transformStagePoint

actorTransformStagePoint

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> Float

x: x screen coordinate of the point to unproject

-> Float

y: y screen coordinate of the point to unproject

-> m (Bool, Float, Float)

Returns: True if conversion was successful.

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 ActorClass.paint() implementation

Since: 0.6

unmap

actorUnmap

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Unsets the ActorFlagsMapped flag on the actor and possibly unmaps its children if they were mapped.

Calling this function is not encouraged: the default Actor implementation of ActorClass.unmap() will also unmap any eventual children by default when their parent is unmapped.

When overriding ActorClass.unmap(), it is mandatory to chain up to the parent implementation.

It is important to note that the implementation of the ActorClass.unmap() virtual function may be called after the ActorClass.destroy() or the ObjectClass.dispose() implementation, but it is guaranteed to be called before the ObjectClass.finalize() implementation.

Since: 1.0

unparent

actorUnparent

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> m ()

Deprecated: (Since version 1.10)Use actorRemoveChild instead.

Removes the parent of self.

This will cause the parent of self to release the reference acquired when calling actorSetParent, so if you want to keep self you will have to acquire a reference of your own, through objectRef.

This function should only be called by legacy Actors implementing the Container interface.

Since: 0.2

unrealize

actorUnrealize

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: A Actor

-> m ()

Deprecated: (Since version 1.16)Actors are automatically unrealized, and nothing requires explicit realization.

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 actorUnrealize in a dispose implementation, then don't, just chain up to ClutterActor's dispose.

If you were using actorUnrealize to implement unrealizing children of your container, then don't, ClutterActor will already take care of that.

unsetFlags

actorUnsetFlags

Arguments

:: (HasCallStack, MonadIO m, IsActor a)

=> a

self: a Actor

-> [ActorFlags]

flags: the flags to unset

-> m ()

Unsets flags on self

This function will emit notifications for the changed properties

Since: 1.0

Properties

actions

Adds a Action to the actor

Since: 1.4

clearActorActions :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “actions” property to Nothing. When overloading is enabled, this is equivalent to

clear #actions

constructActorActions :: (IsActor o, MonadIO m, IsAction a) => a -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “actions” property. This is rarely needed directly, but it is used by new.

setActorActions :: (MonadIO m, IsActor o, IsAction a) => o -> a -> m ()

Set the value of the “actions” property. When overloading is enabled, this is equivalent to

set actor [ #actions := value ]

allocation

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

Since: 0.8

getActorAllocation :: (MonadIO m, IsActor o) => o -> m (Maybe ActorBox)

Get the value of the “allocation” property. When overloading is enabled, this is equivalent to

get actor #allocation

anchorGravity

The anchor point expressed as a Gravity

It is highly recommended not to use Actor:anchor-x, Actor:anchor-y, and Actor:anchor-gravity in newly written code; the anchor point adds an additional translation that will affect the actor's relative position with regards to its parent, as well as the position of its children. This change needs to always be taken into account when positioning the actor. It is recommended to use the Actor:pivot-point property instead, as it will affect only the transformations.

Since: 1.0

constructActorAnchorGravity :: (IsActor o, MonadIO m) => Gravity -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “anchor-gravity” property. This is rarely needed directly, but it is used by new.

getActorAnchorGravity :: (MonadIO m, IsActor o) => o -> m Gravity

Get the value of the “anchor-gravity” property. When overloading is enabled, this is equivalent to

get actor #anchorGravity

setActorAnchorGravity :: (MonadIO m, IsActor o) => o -> Gravity -> m ()

Set the value of the “anchor-gravity” property. When overloading is enabled, this is equivalent to

set actor [ #anchorGravity := value ]

anchorX

The X coordinate of an actor's anchor point, relative to the actor coordinate space, in pixels.

It is highly recommended not to use Actor:anchor-x, Actor:anchor-y, and Actor:anchor-gravity in newly written code; the anchor point adds an additional translation that will affect the actor's relative position with regards to its parent, as well as the position of its children. This change needs to always be taken into account when positioning the actor. It is recommended to use the Actor:pivot-point property instead, as it will affect only the transformations.

Since: 0.8

constructActorAnchorX :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “anchor-x” property. This is rarely needed directly, but it is used by new.

getActorAnchorX :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “anchor-x” property. When overloading is enabled, this is equivalent to

get actor #anchorX

setActorAnchorX :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “anchor-x” property. When overloading is enabled, this is equivalent to

set actor [ #anchorX := value ]

anchorY

The Y coordinate of an actor's anchor point, relative to the actor coordinate space, in pixels

It is highly recommended not to use Actor:anchor-x, Actor:anchor-y, and Actor:anchor-gravity in newly written code; the anchor point adds an additional translation that will affect the actor's relative position with regards to its parent, as well as the position of its children. This change needs to always be taken into account when positioning the actor. It is recommended to use the Actor:pivot-point property instead, as it will affect only the transformations.

Since: 0.8

constructActorAnchorY :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “anchor-y” property. This is rarely needed directly, but it is used by new.

getActorAnchorY :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “anchor-y” property. When overloading is enabled, this is equivalent to

get actor #anchorY

setActorAnchorY :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “anchor-y” property. When overloading is enabled, this is equivalent to

set actor [ #anchorY := value ]

backgroundColor

Paints a solid fill of the actor's allocation using the specified color.

The Actor:background-color property is animatable.

Since: 1.10

clearActorBackgroundColor :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “background-color” property to Nothing. When overloading is enabled, this is equivalent to

clear #backgroundColor

constructActorBackgroundColor :: (IsActor o, MonadIO m) => Color -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “background-color” property. This is rarely needed directly, but it is used by new.

getActorBackgroundColor :: (MonadIO m, IsActor o) => o -> m (Maybe Color)

Get the value of the “background-color” property. When overloading is enabled, this is equivalent to

get actor #backgroundColor

setActorBackgroundColor :: (MonadIO m, IsActor o) => o -> Color -> m ()

Set the value of the “background-color” property. When overloading is enabled, this is equivalent to

set actor [ #backgroundColor := value ]

backgroundColorSet

Whether the Actor:background-color property has been set.

Since: 1.10

getActorBackgroundColorSet :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “background-color-set” property. When overloading is enabled, this is equivalent to

get actor #backgroundColorSet

childTransform

Applies a transformation matrix on each child of an actor.

Setting this property with a Matrix will set the Actor:child-transform-set property to True as a side effect; setting this property with Nothing will set the Actor:child-transform-set property to False.

The Actor:child-transform property is animatable.

Since: 1.12

clearActorChildTransform :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “child-transform” property to Nothing. When overloading is enabled, this is equivalent to

clear #childTransform

constructActorChildTransform :: (IsActor o, MonadIO m) => Matrix -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “child-transform” property. This is rarely needed directly, but it is used by new.

getActorChildTransform :: (MonadIO m, IsActor o) => o -> m (Maybe Matrix)

Get the value of the “child-transform” property. When overloading is enabled, this is equivalent to

get actor #childTransform

setActorChildTransform :: (MonadIO m, IsActor o) => o -> Matrix -> m ()

Set the value of the “child-transform” property. When overloading is enabled, this is equivalent to

set actor [ #childTransform := value ]

childTransformSet

Whether the Actor:child-transform property is set.

Since: 1.12

getActorChildTransformSet :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “child-transform-set” property. When overloading is enabled, this is equivalent to

get actor #childTransformSet

clip

The visible region of the actor, in actor-relative coordinates

clearActorClip :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “clip” property to Nothing. When overloading is enabled, this is equivalent to

clear #clip

constructActorClip :: (IsActor o, MonadIO m) => Geometry -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “clip” property. This is rarely needed directly, but it is used by new.

getActorClip :: (MonadIO m, IsActor o) => o -> m (Maybe Geometry)

Get the value of the “clip” property. When overloading is enabled, this is equivalent to

get actor #clip

setActorClip :: (MonadIO m, IsActor o) => o -> Geometry -> m ()

Set the value of the “clip” property. When overloading is enabled, this is equivalent to

set actor [ #clip := value ]

clipRect

The visible region of the actor, in actor-relative coordinates, expressed as a Rect.

Setting this property to Nothing will unset the existing clip.

Setting this property will change the Actor:has-clip property as a side effect.

Since: 1.12

clearActorClipRect :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “clip-rect” property to Nothing. When overloading is enabled, this is equivalent to

clear #clipRect

constructActorClipRect :: (IsActor o, MonadIO m) => Rect -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “clip-rect” property. This is rarely needed directly, but it is used by new.

getActorClipRect :: (MonadIO m, IsActor o) => o -> m (Maybe Rect)

Get the value of the “clip-rect” property. When overloading is enabled, this is equivalent to

get actor #clipRect

setActorClipRect :: (MonadIO m, IsActor o) => o -> Rect -> m ()

Set the value of the “clip-rect” property. When overloading is enabled, this is equivalent to

set actor [ #clipRect := value ]

clipToAllocation

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 actorSetClip.

Since: 1.0

constructActorClipToAllocation :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “clip-to-allocation” property. This is rarely needed directly, but it is used by new.

getActorClipToAllocation :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “clip-to-allocation” property. When overloading is enabled, this is equivalent to

get actor #clipToAllocation

setActorClipToAllocation :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “clip-to-allocation” property. When overloading is enabled, this is equivalent to

set actor [ #clipToAllocation := value ]

constraints

Adds a Constraint to the actor

Since: 1.4

clearActorConstraints :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “constraints” property to Nothing. When overloading is enabled, this is equivalent to

clear #constraints

constructActorConstraints :: (IsActor o, MonadIO m, IsConstraint a) => a -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “constraints” property. This is rarely needed directly, but it is used by new.

setActorConstraints :: (MonadIO m, IsActor o, IsConstraint a) => o -> a -> m ()

Set the value of the “constraints” property. When overloading is enabled, this is equivalent to

set actor [ #constraints := value ]

content

The Content implementation that controls the content of the actor.

Since: 1.10

clearActorContent :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “content” property to Nothing. When overloading is enabled, this is equivalent to

clear #content

constructActorContent :: (IsActor o, MonadIO m, IsContent a) => a -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “content” property. This is rarely needed directly, but it is used by new.

getActorContent :: (MonadIO m, IsActor o) => o -> m Content

Get the value of the “content” property. When overloading is enabled, this is equivalent to

get actor #content

setActorContent :: (MonadIO m, IsActor o, IsContent a) => o -> a -> m ()

Set the value of the “content” property. When overloading is enabled, this is equivalent to

set actor [ #content := value ]

contentBox

The bounding box for the Content used by the actor.

The value of this property is controlled by the Actor:allocation and Actor:content-gravity properties of Actor.

The bounding box for the content is guaranteed to never exceed the allocation's of the actor.

Since: 1.10

getActorContentBox :: (MonadIO m, IsActor o) => o -> m (Maybe ActorBox)

Get the value of the “content-box” property. When overloading is enabled, this is equivalent to

get actor #contentBox

contentGravity

The alignment that should be honoured by the Content set with the Actor:content property.

Changing the value of this property will change the bounding box of the content; you can use the Actor:content-box property to get the position and size of the content within the actor's allocation.

This property is meaningful only for Content implementations that have a preferred size, and if the preferred size is smaller than the actor's allocation.

The Actor:content-gravity property is animatable.

Since: 1.10

constructActorContentGravity :: (IsActor o, MonadIO m) => ContentGravity -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “content-gravity” property. This is rarely needed directly, but it is used by new.

getActorContentGravity :: (MonadIO m, IsActor o) => o -> m ContentGravity

Get the value of the “content-gravity” property. When overloading is enabled, this is equivalent to

get actor #contentGravity

setActorContentGravity :: (MonadIO m, IsActor o) => o -> ContentGravity -> m ()

Set the value of the “content-gravity” property. When overloading is enabled, this is equivalent to

set actor [ #contentGravity := value ]

contentRepeat

The repeat policy for the actor's Actor:content.

Since: 1.12

constructActorContentRepeat :: (IsActor o, MonadIO m) => [ContentRepeat] -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “content-repeat” property. This is rarely needed directly, but it is used by new.

getActorContentRepeat :: (MonadIO m, IsActor o) => o -> m [ContentRepeat]

Get the value of the “content-repeat” property. When overloading is enabled, this is equivalent to

get actor #contentRepeat

setActorContentRepeat :: (MonadIO m, IsActor o) => o -> [ContentRepeat] -> m ()

Set the value of the “content-repeat” property. When overloading is enabled, this is equivalent to

set actor [ #contentRepeat := value ]

depth

The position of the actor on the Z axis.

The Actor:depth property is relative to the parent's modelview matrix.

Setting this property will call ContainerIface.sort_depth_order() which is usually a no-op, and it's most likely not what you want.

The Actor:depth property is animatable.

Since: 0.6

constructActorDepth :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “depth” property. This is rarely needed directly, but it is used by new.

getActorDepth :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “depth” property. When overloading is enabled, this is equivalent to

get actor #depth

setActorDepth :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “depth” property. When overloading is enabled, this is equivalent to

set actor [ #depth := value ]

effect

Adds Effect to the list of effects be applied on a Actor

Since: 1.4

clearActorEffect :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “effect” property to Nothing. When overloading is enabled, this is equivalent to

clear #effect

constructActorEffect :: (IsActor o, MonadIO m, IsEffect a) => a -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “effect” property. This is rarely needed directly, but it is used by new.

setActorEffect :: (MonadIO m, IsActor o, IsEffect a) => o -> a -> m ()

Set the value of the “effect” property. When overloading is enabled, this is equivalent to

set actor [ #effect := value ]

firstChild

The actor's first child.

Since: 1.10

getActorFirstChild :: (MonadIO m, IsActor o) => o -> m Actor

Get the value of the “first-child” property. When overloading is enabled, this is equivalent to

get actor #firstChild

fixedPositionSet

This flag controls whether the Actor:fixed-x and Actor:fixed-y properties are used

Since: 0.8

constructActorFixedPositionSet :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “fixed-position-set” property. This is rarely needed directly, but it is used by new.

getActorFixedPositionSet :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “fixed-position-set” property. When overloading is enabled, this is equivalent to

get actor #fixedPositionSet

setActorFixedPositionSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “fixed-position-set” property. When overloading is enabled, this is equivalent to

set actor [ #fixedPositionSet := value ]

fixedX

The fixed X position of the actor in pixels.

Writing this property sets Actor:fixed-position-set property as well, as a side effect

Since: 0.8

constructActorFixedX :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “fixed-x” property. This is rarely needed directly, but it is used by new.

getActorFixedX :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “fixed-x” property. When overloading is enabled, this is equivalent to

get actor #fixedX

setActorFixedX :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “fixed-x” property. When overloading is enabled, this is equivalent to

set actor [ #fixedX := value ]

fixedY

The fixed Y position of the actor in pixels.

Writing this property sets the Actor:fixed-position-set property as well, as a side effect

Since: 0.8

constructActorFixedY :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “fixed-y” property. This is rarely needed directly, but it is used by new.

getActorFixedY :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “fixed-y” property. When overloading is enabled, this is equivalent to

get actor #fixedY

setActorFixedY :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “fixed-y” property. When overloading is enabled, this is equivalent to

set actor [ #fixedY := value ]

hasClip

Whether the actor has the Actor:clip property set or not

getActorHasClip :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “has-clip” property. When overloading is enabled, this is equivalent to

get actor #hasClip

hasPointer

Whether the actor contains the pointer of a InputDevice or not.

Since: 1.2

getActorHasPointer :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “has-pointer” property. When overloading is enabled, this is equivalent to

get actor #hasPointer

height

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 Actor:height property is animatable.

constructActorHeight :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “height” property. This is rarely needed directly, but it is used by new.

getActorHeight :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “height” property. When overloading is enabled, this is equivalent to

get actor #height

setActorHeight :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “height” property. When overloading is enabled, this is equivalent to

set actor [ #height := value ]

lastChild

The actor's last child.

Since: 1.10

getActorLastChild :: (MonadIO m, IsActor o) => o -> m Actor

Get the value of the “last-child” property. When overloading is enabled, this is equivalent to

get actor #lastChild

layoutManager

A delegate object for controlling the layout of the children of an actor.

Since: 1.10

clearActorLayoutManager :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “layout-manager” property to Nothing. When overloading is enabled, this is equivalent to

clear #layoutManager

constructActorLayoutManager :: (IsActor o, MonadIO m, IsLayoutManager a) => a -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “layout-manager” property. This is rarely needed directly, but it is used by new.

getActorLayoutManager :: (MonadIO m, IsActor o) => o -> m LayoutManager

Get the value of the “layout-manager” property. When overloading is enabled, this is equivalent to

get actor #layoutManager

setActorLayoutManager :: (MonadIO m, IsActor o, IsLayoutManager a) => o -> a -> m ()

Set the value of the “layout-manager” property. When overloading is enabled, this is equivalent to

set actor [ #layoutManager := value ]

magnificationFilter

No description available in the introspection data.

constructActorMagnificationFilter :: (IsActor o, MonadIO m) => ScalingFilter -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “magnification-filter” property. This is rarely needed directly, but it is used by new.

getActorMagnificationFilter :: (MonadIO m, IsActor o) => o -> m ScalingFilter

Get the value of the “magnification-filter” property. When overloading is enabled, this is equivalent to

get actor #magnificationFilter

setActorMagnificationFilter :: (MonadIO m, IsActor o) => o -> ScalingFilter -> m ()

Set the value of the “magnification-filter” property. When overloading is enabled, this is equivalent to

set actor [ #magnificationFilter := value ]

mapped

Whether the actor is mapped (will be painted when the stage to which it belongs is mapped)

Since: 1.0

getActorMapped :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “mapped” property. When overloading is enabled, this is equivalent to

get actor #mapped

marginBottom

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 Actor:margin-bottom property is animatable.

Since: 1.10

constructActorMarginBottom :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin-bottom” property. This is rarely needed directly, but it is used by new.

getActorMarginBottom :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “margin-bottom” property. When overloading is enabled, this is equivalent to

get actor #marginBottom

setActorMarginBottom :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “margin-bottom” property. When overloading is enabled, this is equivalent to

set actor [ #marginBottom := value ]

marginLeft

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 Actor:margin-left property is animatable.

Since: 1.10

constructActorMarginLeft :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin-left” property. This is rarely needed directly, but it is used by new.

getActorMarginLeft :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “margin-left” property. When overloading is enabled, this is equivalent to

get actor #marginLeft

setActorMarginLeft :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “margin-left” property. When overloading is enabled, this is equivalent to

set actor [ #marginLeft := value ]

marginRight

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 Actor:margin-right property is animatable.

Since: 1.10

constructActorMarginRight :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin-right” property. This is rarely needed directly, but it is used by new.

getActorMarginRight :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “margin-right” property. When overloading is enabled, this is equivalent to

get actor #marginRight

setActorMarginRight :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “margin-right” property. When overloading is enabled, this is equivalent to

set actor [ #marginRight := value ]

marginTop

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 Actor:margin-top property is animatable.

Since: 1.10

constructActorMarginTop :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin-top” property. This is rarely needed directly, but it is used by new.

getActorMarginTop :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “margin-top” property. When overloading is enabled, this is equivalent to

get actor #marginTop

setActorMarginTop :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “margin-top” property. When overloading is enabled, this is equivalent to

set actor [ #marginTop := value ]

minHeight

A forced minimum height request for the actor, in pixels

Writing this property sets the Actor:min-height-set property as well, as a side effect. This property overrides the usual height request of the actor.

Since: 0.8

constructActorMinHeight :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “min-height” property. This is rarely needed directly, but it is used by new.

getActorMinHeight :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “min-height” property. When overloading is enabled, this is equivalent to

get actor #minHeight

setActorMinHeight :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “min-height” property. When overloading is enabled, this is equivalent to

set actor [ #minHeight := value ]

minHeightSet

This flag controls whether the Actor:min-height property is used

Since: 0.8

constructActorMinHeightSet :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “min-height-set” property. This is rarely needed directly, but it is used by new.

getActorMinHeightSet :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “min-height-set” property. When overloading is enabled, this is equivalent to

get actor #minHeightSet

setActorMinHeightSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “min-height-set” property. When overloading is enabled, this is equivalent to

set actor [ #minHeightSet := value ]

minWidth

A forced minimum width request for the actor, in pixels

Writing this property sets the Actor:min-width-set property as well, as a side effect.

This property overrides the usual width request of the actor.

Since: 0.8

constructActorMinWidth :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “min-width” property. This is rarely needed directly, but it is used by new.

getActorMinWidth :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “min-width” property. When overloading is enabled, this is equivalent to

get actor #minWidth

setActorMinWidth :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “min-width” property. When overloading is enabled, this is equivalent to

set actor [ #minWidth := value ]

minWidthSet

This flag controls whether the Actor:min-width property is used

Since: 0.8

constructActorMinWidthSet :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “min-width-set” property. This is rarely needed directly, but it is used by new.

getActorMinWidthSet :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “min-width-set” property. When overloading is enabled, this is equivalent to

get actor #minWidthSet

setActorMinWidthSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “min-width-set” property. When overloading is enabled, this is equivalent to

set actor [ #minWidthSet := value ]

minificationFilter

No description available in the introspection data.

constructActorMinificationFilter :: (IsActor o, MonadIO m) => ScalingFilter -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “minification-filter” property. This is rarely needed directly, but it is used by new.

getActorMinificationFilter :: (MonadIO m, IsActor o) => o -> m ScalingFilter

Get the value of the “minification-filter” property. When overloading is enabled, this is equivalent to

get actor #minificationFilter

setActorMinificationFilter :: (MonadIO m, IsActor o) => o -> ScalingFilter -> m ()

Set the value of the “minification-filter” property. When overloading is enabled, this is equivalent to

set actor [ #minificationFilter := value ]

name

The name of the actor

Since: 0.2

constructActorName :: (IsActor o, MonadIO m) => Text -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “name” property. This is rarely needed directly, but it is used by new.

getActorName :: (MonadIO m, IsActor o) => o -> m Text

Get the value of the “name” property. When overloading is enabled, this is equivalent to

get actor #name

setActorName :: (MonadIO m, IsActor o) => o -> Text -> m ()

Set the value of the “name” property. When overloading is enabled, this is equivalent to

set actor [ #name := value ]

naturalHeight

A forced natural height request for the actor, in pixels

Writing this property sets the Actor:natural-height-set property as well, as a side effect. This property overrides the usual height request of the actor

Since: 0.8

constructActorNaturalHeight :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “natural-height” property. This is rarely needed directly, but it is used by new.

getActorNaturalHeight :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “natural-height” property. When overloading is enabled, this is equivalent to

get actor #naturalHeight

setActorNaturalHeight :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “natural-height” property. When overloading is enabled, this is equivalent to

set actor [ #naturalHeight := value ]

naturalHeightSet

This flag controls whether the Actor:natural-height property is used

Since: 0.8

constructActorNaturalHeightSet :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “natural-height-set” property. This is rarely needed directly, but it is used by new.

getActorNaturalHeightSet :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “natural-height-set” property. When overloading is enabled, this is equivalent to

get actor #naturalHeightSet

setActorNaturalHeightSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “natural-height-set” property. When overloading is enabled, this is equivalent to

set actor [ #naturalHeightSet := value ]

naturalWidth

A forced natural width request for the actor, in pixels

Writing this property sets the Actor:natural-width-set property as well, as a side effect. This property overrides the usual width request of the actor

Since: 0.8

constructActorNaturalWidth :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “natural-width” property. This is rarely needed directly, but it is used by new.

getActorNaturalWidth :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “natural-width” property. When overloading is enabled, this is equivalent to

get actor #naturalWidth

setActorNaturalWidth :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “natural-width” property. When overloading is enabled, this is equivalent to

set actor [ #naturalWidth := value ]

naturalWidthSet

This flag controls whether the Actor:natural-width property is used

Since: 0.8

constructActorNaturalWidthSet :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “natural-width-set” property. This is rarely needed directly, but it is used by new.

getActorNaturalWidthSet :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “natural-width-set” property. When overloading is enabled, this is equivalent to

get actor #naturalWidthSet

setActorNaturalWidthSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “natural-width-set” property. When overloading is enabled, this is equivalent to

set actor [ #naturalWidthSet := value ]

offscreenRedirect

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 actorSetOffscreenRedirect for details.

Since: 1.8

constructActorOffscreenRedirect :: (IsActor o, MonadIO m) => [OffscreenRedirect] -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “offscreen-redirect” property. This is rarely needed directly, but it is used by new.

getActorOffscreenRedirect :: (MonadIO m, IsActor o) => o -> m [OffscreenRedirect]

Get the value of the “offscreen-redirect” property. When overloading is enabled, this is equivalent to

get actor #offscreenRedirect

setActorOffscreenRedirect :: (MonadIO m, IsActor o) => o -> [OffscreenRedirect] -> m ()

Set the value of the “offscreen-redirect” property. When overloading is enabled, this is equivalent to

set actor [ #offscreenRedirect := value ]

opacity

Opacity of an actor, between 0 (fully transparent) and 255 (fully opaque)

The Actor:opacity property is animatable.

constructActorOpacity :: (IsActor o, MonadIO m) => Word32 -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “opacity” property. This is rarely needed directly, but it is used by new.

getActorOpacity :: (MonadIO m, IsActor o) => o -> m Word32

Get the value of the “opacity” property. When overloading is enabled, this is equivalent to

get actor #opacity

setActorOpacity :: (MonadIO m, IsActor o) => o -> Word32 -> m ()

Set the value of the “opacity” property. When overloading is enabled, this is equivalent to

set actor [ #opacity := value ]

pivotPoint

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 Actor:pivot-point property is animatable.

Since: 1.12

clearActorPivotPoint :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “pivot-point” property to Nothing. When overloading is enabled, this is equivalent to

clear #pivotPoint

constructActorPivotPoint :: (IsActor o, MonadIO m) => Point -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “pivot-point” property. This is rarely needed directly, but it is used by new.

getActorPivotPoint :: (MonadIO m, IsActor o) => o -> m (Maybe Point)

Get the value of the “pivot-point” property. When overloading is enabled, this is equivalent to

get actor #pivotPoint

setActorPivotPoint :: (MonadIO m, IsActor o) => o -> Point -> m ()

Set the value of the “pivot-point” property. When overloading is enabled, this is equivalent to

set actor [ #pivotPoint := value ]

pivotPointZ

The Z component of the Actor:pivot-point, expressed as a value along the Z axis.

The Actor:pivot-point-z property is animatable.

Since: 1.12

constructActorPivotPointZ :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “pivot-point-z” property. This is rarely needed directly, but it is used by new.

getActorPivotPointZ :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “pivot-point-z” property. When overloading is enabled, this is equivalent to

get actor #pivotPointZ

setActorPivotPointZ :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “pivot-point-z” property. When overloading is enabled, this is equivalent to

set actor [ #pivotPointZ := value ]

position

The position of the origin of the actor.

This property is a shorthand for setting and getting the Actor:x and Actor:y properties at the same time.

The Actor:position property is animatable.

Since: 1.12

clearActorPosition :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “position” property to Nothing. When overloading is enabled, this is equivalent to

clear #position

constructActorPosition :: (IsActor o, MonadIO m) => Point -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “position” property. This is rarely needed directly, but it is used by new.

getActorPosition :: (MonadIO m, IsActor o) => o -> m (Maybe Point)

Get the value of the “position” property. When overloading is enabled, this is equivalent to

get actor #position

setActorPosition :: (MonadIO m, IsActor o) => o -> Point -> m ()

Set the value of the “position” property. When overloading is enabled, this is equivalent to

set actor [ #position := value ]

reactive

Whether the actor is reactive to events or not

Only reactive actors will emit event-related signals

Since: 0.6

constructActorReactive :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “reactive” property. This is rarely needed directly, but it is used by new.

getActorReactive :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “reactive” property. When overloading is enabled, this is equivalent to

get actor #reactive

setActorReactive :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “reactive” property. When overloading is enabled, this is equivalent to

set actor [ #reactive := value ]

realized

Whether the actor has been realized

Since: 1.0

getActorRealized :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “realized” property. When overloading is enabled, this is equivalent to

get actor #realized

requestMode

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.

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 code

 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 Actor "child".

The actorGetPreferredSize function will implement this check for you.

Since: 0.8

constructActorRequestMode :: (IsActor o, MonadIO m) => RequestMode -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “request-mode” property. This is rarely needed directly, but it is used by new.

getActorRequestMode :: (MonadIO m, IsActor o) => o -> m RequestMode

Get the value of the “request-mode” property. When overloading is enabled, this is equivalent to

get actor #requestMode

setActorRequestMode :: (MonadIO m, IsActor o) => o -> RequestMode -> m ()

Set the value of the “request-mode” property. When overloading is enabled, this is equivalent to

set actor [ #requestMode := value ]

rotationAngleX

The rotation angle on the X axis.

The Actor:rotation-angle-x property is animatable.

Since: 0.6

constructActorRotationAngleX :: (IsActor o, MonadIO m) => Double -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “rotation-angle-x” property. This is rarely needed directly, but it is used by new.

getActorRotationAngleX :: (MonadIO m, IsActor o) => o -> m Double

Get the value of the “rotation-angle-x” property. When overloading is enabled, this is equivalent to

get actor #rotationAngleX

setActorRotationAngleX :: (MonadIO m, IsActor o) => o -> Double -> m ()

Set the value of the “rotation-angle-x” property. When overloading is enabled, this is equivalent to

set actor [ #rotationAngleX := value ]

rotationAngleY

The rotation angle on the Y axis

The Actor:rotation-angle-y property is animatable.

Since: 0.6

constructActorRotationAngleY :: (IsActor o, MonadIO m) => Double -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “rotation-angle-y” property. This is rarely needed directly, but it is used by new.

getActorRotationAngleY :: (MonadIO m, IsActor o) => o -> m Double

Get the value of the “rotation-angle-y” property. When overloading is enabled, this is equivalent to

get actor #rotationAngleY

setActorRotationAngleY :: (MonadIO m, IsActor o) => o -> Double -> m ()

Set the value of the “rotation-angle-y” property. When overloading is enabled, this is equivalent to

set actor [ #rotationAngleY := value ]

rotationAngleZ

The rotation angle on the Z axis

The Actor:rotation-angle-z property is animatable.

Since: 0.6

constructActorRotationAngleZ :: (IsActor o, MonadIO m) => Double -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “rotation-angle-z” property. This is rarely needed directly, but it is used by new.

getActorRotationAngleZ :: (MonadIO m, IsActor o) => o -> m Double

Get the value of the “rotation-angle-z” property. When overloading is enabled, this is equivalent to

get actor #rotationAngleZ

setActorRotationAngleZ :: (MonadIO m, IsActor o) => o -> Double -> m ()

Set the value of the “rotation-angle-z” property. When overloading is enabled, this is equivalent to

set actor [ #rotationAngleZ := value ]

rotationCenterX

The rotation center on the X axis.

Since: 0.6

clearActorRotationCenterX :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “rotation-center-x” property to Nothing. When overloading is enabled, this is equivalent to

clear #rotationCenterX

constructActorRotationCenterX :: (IsActor o, MonadIO m) => Vertex -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “rotation-center-x” property. This is rarely needed directly, but it is used by new.

getActorRotationCenterX :: (MonadIO m, IsActor o) => o -> m (Maybe Vertex)

Get the value of the “rotation-center-x” property. When overloading is enabled, this is equivalent to

get actor #rotationCenterX

setActorRotationCenterX :: (MonadIO m, IsActor o) => o -> Vertex -> m ()

Set the value of the “rotation-center-x” property. When overloading is enabled, this is equivalent to

set actor [ #rotationCenterX := value ]

rotationCenterY

The rotation center on the Y axis.

Since: 0.6

clearActorRotationCenterY :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “rotation-center-y” property to Nothing. When overloading is enabled, this is equivalent to

clear #rotationCenterY

constructActorRotationCenterY :: (IsActor o, MonadIO m) => Vertex -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “rotation-center-y” property. This is rarely needed directly, but it is used by new.

getActorRotationCenterY :: (MonadIO m, IsActor o) => o -> m (Maybe Vertex)

Get the value of the “rotation-center-y” property. When overloading is enabled, this is equivalent to

get actor #rotationCenterY

setActorRotationCenterY :: (MonadIO m, IsActor o) => o -> Vertex -> m ()

Set the value of the “rotation-center-y” property. When overloading is enabled, this is equivalent to

set actor [ #rotationCenterY := value ]

rotationCenterZ

The rotation center on the Z axis.

Since: 0.6

clearActorRotationCenterZ :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “rotation-center-z” property to Nothing. When overloading is enabled, this is equivalent to

clear #rotationCenterZ

constructActorRotationCenterZ :: (IsActor o, MonadIO m) => Vertex -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “rotation-center-z” property. This is rarely needed directly, but it is used by new.

getActorRotationCenterZ :: (MonadIO m, IsActor o) => o -> m (Maybe Vertex)

Get the value of the “rotation-center-z” property. When overloading is enabled, this is equivalent to

get actor #rotationCenterZ

setActorRotationCenterZ :: (MonadIO m, IsActor o) => o -> Vertex -> m ()

Set the value of the “rotation-center-z” property. When overloading is enabled, this is equivalent to

set actor [ #rotationCenterZ := value ]

rotationCenterZGravity

The rotation center on the Z axis expressed as a Gravity.

Since: 1.0

constructActorRotationCenterZGravity :: (IsActor o, MonadIO m) => Gravity -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “rotation-center-z-gravity” property. This is rarely needed directly, but it is used by new.

getActorRotationCenterZGravity :: (MonadIO m, IsActor o) => o -> m Gravity

Get the value of the “rotation-center-z-gravity” property. When overloading is enabled, this is equivalent to

get actor #rotationCenterZGravity

setActorRotationCenterZGravity :: (MonadIO m, IsActor o) => o -> Gravity -> m ()

Set the value of the “rotation-center-z-gravity” property. When overloading is enabled, this is equivalent to

set actor [ #rotationCenterZGravity := value ]

scaleCenterX

The horizontal center point for scaling

Since: 1.0

constructActorScaleCenterX :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “scale-center-x” property. This is rarely needed directly, but it is used by new.

getActorScaleCenterX :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “scale-center-x” property. When overloading is enabled, this is equivalent to

get actor #scaleCenterX

setActorScaleCenterX :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “scale-center-x” property. When overloading is enabled, this is equivalent to

set actor [ #scaleCenterX := value ]

scaleCenterY

The vertical center point for scaling

Since: 1.0

constructActorScaleCenterY :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “scale-center-y” property. This is rarely needed directly, but it is used by new.

getActorScaleCenterY :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “scale-center-y” property. When overloading is enabled, this is equivalent to

get actor #scaleCenterY

setActorScaleCenterY :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “scale-center-y” property. When overloading is enabled, this is equivalent to

set actor [ #scaleCenterY := value ]

scaleGravity

The center point for scaling expressed as a Gravity

Since: 1.0

constructActorScaleGravity :: (IsActor o, MonadIO m) => Gravity -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “scale-gravity” property. This is rarely needed directly, but it is used by new.

getActorScaleGravity :: (MonadIO m, IsActor o) => o -> m Gravity

Get the value of the “scale-gravity” property. When overloading is enabled, this is equivalent to

get actor #scaleGravity

setActorScaleGravity :: (MonadIO m, IsActor o) => o -> Gravity -> m ()

Set the value of the “scale-gravity” property. When overloading is enabled, this is equivalent to

set actor [ #scaleGravity := value ]

scaleX

The horizontal scale of the actor.

The Actor:scale-x property is animatable.

Since: 0.6

constructActorScaleX :: (IsActor o, MonadIO m) => Double -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “scale-x” property. This is rarely needed directly, but it is used by new.

getActorScaleX :: (MonadIO m, IsActor o) => o -> m Double

Get the value of the “scale-x” property. When overloading is enabled, this is equivalent to

get actor #scaleX

setActorScaleX :: (MonadIO m, IsActor o) => o -> Double -> m ()

Set the value of the “scale-x” property. When overloading is enabled, this is equivalent to

set actor [ #scaleX := value ]

scaleY

The vertical scale of the actor.

The Actor:scale-y property is animatable.

Since: 0.6

constructActorScaleY :: (IsActor o, MonadIO m) => Double -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “scale-y” property. This is rarely needed directly, but it is used by new.

getActorScaleY :: (MonadIO m, IsActor o) => o -> m Double

Get the value of the “scale-y” property. When overloading is enabled, this is equivalent to

get actor #scaleY

setActorScaleY :: (MonadIO m, IsActor o) => o -> Double -> m ()

Set the value of the “scale-y” property. When overloading is enabled, this is equivalent to

set actor [ #scaleY := value ]

scaleZ

The scale factor of the actor along the Z axis.

The Actor:scale-y property is animatable.

Since: 1.12

constructActorScaleZ :: (IsActor o, MonadIO m) => Double -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “scale-z” property. This is rarely needed directly, but it is used by new.

getActorScaleZ :: (MonadIO m, IsActor o) => o -> m Double

Get the value of the “scale-z” property. When overloading is enabled, this is equivalent to

get actor #scaleZ

setActorScaleZ :: (MonadIO m, IsActor o) => o -> Double -> m ()

Set the value of the “scale-z” property. When overloading is enabled, this is equivalent to

set actor [ #scaleZ := value ]

showOnSetParent

If True, the actor is automatically shown when parented.

Calling actorHide on an actor which has not been parented will set this property to False as a side effect.

Since: 0.8

constructActorShowOnSetParent :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “show-on-set-parent” property. This is rarely needed directly, but it is used by new.

getActorShowOnSetParent :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “show-on-set-parent” property. When overloading is enabled, this is equivalent to

get actor #showOnSetParent

setActorShowOnSetParent :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “show-on-set-parent” property. When overloading is enabled, this is equivalent to

set actor [ #showOnSetParent := value ]

size

The size of the actor.

This property is a shorthand for setting and getting the Actor:width and Actor:height at the same time.

The Actor:size property is animatable.

Since: 1.12

clearActorSize :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “size” property to Nothing. When overloading is enabled, this is equivalent to

clear #size

constructActorSize :: (IsActor o, MonadIO m) => Size -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “size” property. This is rarely needed directly, but it is used by new.

getActorSize :: (MonadIO m, IsActor o) => o -> m (Maybe Size)

Get the value of the “size” property. When overloading is enabled, this is equivalent to

get actor #size

setActorSize :: (MonadIO m, IsActor o) => o -> Size -> m ()

Set the value of the “size” property. When overloading is enabled, this is equivalent to

set actor [ #size := value ]

textDirection

The direction of the text inside a Actor.

Since: 1.0

constructActorTextDirection :: (IsActor o, MonadIO m) => TextDirection -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “text-direction” property. This is rarely needed directly, but it is used by new.

getActorTextDirection :: (MonadIO m, IsActor o) => o -> m TextDirection

Get the value of the “text-direction” property. When overloading is enabled, this is equivalent to

get actor #textDirection

setActorTextDirection :: (MonadIO m, IsActor o) => o -> TextDirection -> m ()

Set the value of the “text-direction” property. When overloading is enabled, this is equivalent to

set actor [ #textDirection := value ]

transform

Overrides the transformations of a Actor with a custom matrix.

The matrix specified by the Actor:transform property is applied to the actor and its children relative to the actor's Actor:allocation and Actor:pivot-point.

Application code should rarely need to use this function directly.

Setting this property with a Matrix will set the Actor:transform-set property to True as a side effect; setting this property with Nothing will set the Actor:transform-set property to False.

The Actor:transform property is animatable.

Since: 1.12

clearActorTransform :: (MonadIO m, IsActor o) => o -> m ()

Set the value of the “transform” property to Nothing. When overloading is enabled, this is equivalent to

clear #transform

constructActorTransform :: (IsActor o, MonadIO m) => Matrix -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “transform” property. This is rarely needed directly, but it is used by new.

getActorTransform :: (MonadIO m, IsActor o) => o -> m (Maybe Matrix)

Get the value of the “transform” property. When overloading is enabled, this is equivalent to

get actor #transform

setActorTransform :: (MonadIO m, IsActor o) => o -> Matrix -> m ()

Set the value of the “transform” property. When overloading is enabled, this is equivalent to

set actor [ #transform := value ]

transformSet

Whether the Actor:transform property is set.

Since: 1.12

getActorTransformSet :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “transform-set” property. When overloading is enabled, this is equivalent to

get actor #transformSet

translationX

An additional translation applied along the X axis, relative to the actor's Actor:pivot-point.

The Actor:translation-x property is animatable.

Since: 1.12

constructActorTranslationX :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “translation-x” property. This is rarely needed directly, but it is used by new.

getActorTranslationX :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “translation-x” property. When overloading is enabled, this is equivalent to

get actor #translationX

setActorTranslationX :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “translation-x” property. When overloading is enabled, this is equivalent to

set actor [ #translationX := value ]

translationY

An additional translation applied along the Y axis, relative to the actor's Actor:pivot-point.

The Actor:translation-y property is animatable.

Since: 1.12

constructActorTranslationY :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “translation-y” property. This is rarely needed directly, but it is used by new.

getActorTranslationY :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “translation-y” property. When overloading is enabled, this is equivalent to

get actor #translationY

setActorTranslationY :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “translation-y” property. When overloading is enabled, this is equivalent to

set actor [ #translationY := value ]

translationZ

An additional translation applied along the Z axis, relative to the actor's Actor:pivot-point.

The Actor:translation-z property is animatable.

Since: 1.12

constructActorTranslationZ :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “translation-z” property. This is rarely needed directly, but it is used by new.

getActorTranslationZ :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “translation-z” property. When overloading is enabled, this is equivalent to

get actor #translationZ

setActorTranslationZ :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “translation-z” property. When overloading is enabled, this is equivalent to

set actor [ #translationZ := value ]

visible

Whether the actor is set to be visible or not

See also Actor:mapped

constructActorVisible :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “visible” property. This is rarely needed directly, but it is used by new.

getActorVisible :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “visible” property. When overloading is enabled, this is equivalent to

get actor #visible

setActorVisible :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “visible” property. When overloading is enabled, this is equivalent to

set actor [ #visible := value ]

width

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 Actor:width property is animatable.

constructActorWidth :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “width” property. This is rarely needed directly, but it is used by new.

getActorWidth :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “width” property. When overloading is enabled, this is equivalent to

get actor #width

setActorWidth :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “width” property. When overloading is enabled, this is equivalent to

set actor [ #width := value ]

x

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 Actor:x property is animatable.

constructActorX :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “x” property. This is rarely needed directly, but it is used by new.

getActorX :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “x” property. When overloading is enabled, this is equivalent to

get actor #x

setActorX :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “x” property. When overloading is enabled, this is equivalent to

set actor [ #x := value ]

xAlign

The alignment of an actor on the X axis, if the actor has been given extra space for its allocation. See also the Actor:x-expand property.

Since: 1.10

constructActorXAlign :: (IsActor o, MonadIO m) => ActorAlign -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “x-align” property. This is rarely needed directly, but it is used by new.

getActorXAlign :: (MonadIO m, IsActor o) => o -> m ActorAlign

Get the value of the “x-align” property. When overloading is enabled, this is equivalent to

get actor #xAlign

setActorXAlign :: (MonadIO m, IsActor o) => o -> ActorAlign -> m ()

Set the value of the “x-align” property. When overloading is enabled, this is equivalent to

set actor [ #xAlign := value ]

xExpand

Whether a layout manager should assign more space to the actor on the X axis.

Since: 1.12

constructActorXExpand :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “x-expand” property. This is rarely needed directly, but it is used by new.

getActorXExpand :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “x-expand” property. When overloading is enabled, this is equivalent to

get actor #xExpand

setActorXExpand :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “x-expand” property. When overloading is enabled, this is equivalent to

set actor [ #xExpand := value ]

y

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 Actor:y property is animatable.

constructActorY :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “y” property. This is rarely needed directly, but it is used by new.

getActorY :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “y” property. When overloading is enabled, this is equivalent to

get actor #y

setActorY :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “y” property. When overloading is enabled, this is equivalent to

set actor [ #y := value ]

yAlign

The alignment of an actor on the Y axis, if the actor has been given extra space for its allocation.

Since: 1.10

constructActorYAlign :: (IsActor o, MonadIO m) => ActorAlign -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “y-align” property. This is rarely needed directly, but it is used by new.

getActorYAlign :: (MonadIO m, IsActor o) => o -> m ActorAlign

Get the value of the “y-align” property. When overloading is enabled, this is equivalent to

get actor #yAlign

setActorYAlign :: (MonadIO m, IsActor o) => o -> ActorAlign -> m ()

Set the value of the “y-align” property. When overloading is enabled, this is equivalent to

set actor [ #yAlign := value ]

yExpand

Whether a layout manager should assign more space to the actor on the Y axis.

Since: 1.12

constructActorYExpand :: (IsActor o, MonadIO m) => Bool -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “y-expand” property. This is rarely needed directly, but it is used by new.

getActorYExpand :: (MonadIO m, IsActor o) => o -> m Bool

Get the value of the “y-expand” property. When overloading is enabled, this is equivalent to

get actor #yExpand

setActorYExpand :: (MonadIO m, IsActor o) => o -> Bool -> m ()

Set the value of the “y-expand” property. When overloading is enabled, this is equivalent to

set actor [ #yExpand := value ]

zPosition

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 Actor:z-position does not affect the paint or allocation order.

The Actor:z-position property is animatable.

Since: 1.12

constructActorZPosition :: (IsActor o, MonadIO m) => Float -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “z-position” property. This is rarely needed directly, but it is used by new.

getActorZPosition :: (MonadIO m, IsActor o) => o -> m Float

Get the value of the “z-position” property. When overloading is enabled, this is equivalent to

get actor #zPosition

setActorZPosition :: (MonadIO m, IsActor o) => o -> Float -> m ()

Set the value of the “z-position” property. When overloading is enabled, this is equivalent to

set actor [ #zPosition := value ]

Signals

allocationChanged

type ActorAllocationChangedCallback

Arguments

 = ActorBox

box: a ActorBox with the new allocation

-> [AllocationFlags]

flags: AllocationFlags for the allocation

-> IO ()

The allocationChanged signal is emitted when the Actor: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.

Since: 1.0

afterActorAllocationChanged :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorAllocationChangedCallback) -> m SignalHandlerId

Connect a signal handler for the allocationChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #allocationChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorAllocationChanged :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorAllocationChangedCallback) -> m SignalHandlerId

Connect a signal handler for the allocationChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #allocationChanged callback

buttonPressEvent

type ActorButtonPressEventCallback

Arguments

 = ButtonEvent

event: a ButtonEvent

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

The buttonPressEvent signal is emitted each time a mouse button is pressed on actor.

Since: 0.6

afterActorButtonPressEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorButtonPressEventCallback) -> m SignalHandlerId

Connect a signal handler for the buttonPressEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #buttonPressEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorButtonPressEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorButtonPressEventCallback) -> m SignalHandlerId

Connect a signal handler for the buttonPressEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #buttonPressEvent callback

buttonReleaseEvent

type ActorButtonReleaseEventCallback

Arguments

 = ButtonEvent

event: a ButtonEvent

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

The buttonReleaseEvent signal is emitted each time a mouse button is released on actor.

Since: 0.6

afterActorButtonReleaseEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorButtonReleaseEventCallback) -> m SignalHandlerId

Connect a signal handler for the buttonReleaseEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #buttonReleaseEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorButtonReleaseEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorButtonReleaseEventCallback) -> m SignalHandlerId

Connect a signal handler for the buttonReleaseEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #buttonReleaseEvent callback

capturedEvent

type ActorCapturedEventCallback

Arguments

 = Event

event: a Event

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

The capturedEvent 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[buttonPressEvent](#g:signal:buttonPressEvent) or keyReleasedEvent) are emitted.

Since: 0.6

afterActorCapturedEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorCapturedEventCallback) -> m SignalHandlerId

Connect a signal handler for the capturedEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #capturedEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorCapturedEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorCapturedEventCallback) -> m SignalHandlerId

Connect a signal handler for the capturedEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #capturedEvent callback

destroy

type ActorDestroyCallback = IO ()

The destroy signal notifies that all references held on the actor which emitted it should be released.

The destroy signal should be used by all holders of a reference on actor.

This signal might result in the finalization of the Actor if all references are released.

Composite actors and actors implementing the Container interface should override the default implementation of the class handler of this signal and call actorDestroy on their children. When overriding the default class handler, it is required to chain up to the parent's implementation.

Since: 0.2

afterActorDestroy :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorDestroyCallback) -> m SignalHandlerId

Connect a signal handler for the destroy signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #destroy callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorDestroy :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorDestroyCallback) -> m SignalHandlerId

Connect a signal handler for the destroy signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #destroy callback

enterEvent

type ActorEnterEventCallback

Arguments

 = CrossingEvent

event: a CrossingEvent

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

The enterEvent signal is emitted when the pointer enters the actor

Since: 0.6

afterActorEnterEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorEnterEventCallback) -> m SignalHandlerId

Connect a signal handler for the enterEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #enterEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorEnterEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorEnterEventCallback) -> m SignalHandlerId

Connect a signal handler for the enterEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #enterEvent callback

event

type ActorEventCallback

Arguments

 = Event

event: a Event

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

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

Since: 0.6

afterActorEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorEventCallback) -> m SignalHandlerId

Connect a signal handler for the event signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #event callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorEventCallback) -> m SignalHandlerId

Connect a signal handler for the event signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #event callback

hide

type ActorHideCallback = IO ()

The hide signal is emitted when an actor is no longer rendered on the stage.

Since: 0.2

afterActorHide :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorHideCallback) -> m SignalHandlerId

Connect a signal handler for the hide signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #hide callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorHide :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorHideCallback) -> m SignalHandlerId

Connect a signal handler for the hide signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #hide callback

keyFocusIn

type ActorKeyFocusInCallback = IO ()

The keyFocusIn signal is emitted when actor receives key focus.

Since: 0.6

afterActorKeyFocusIn :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyFocusInCallback) -> m SignalHandlerId

Connect a signal handler for the keyFocusIn signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #keyFocusIn callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorKeyFocusIn :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyFocusInCallback) -> m SignalHandlerId

Connect a signal handler for the keyFocusIn signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #keyFocusIn callback

keyFocusOut

type ActorKeyFocusOutCallback = IO ()

The keyFocusOut signal is emitted when actor loses key focus.

Since: 0.6

afterActorKeyFocusOut :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyFocusOutCallback) -> m SignalHandlerId

Connect a signal handler for the keyFocusOut signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #keyFocusOut callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorKeyFocusOut :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyFocusOutCallback) -> m SignalHandlerId

Connect a signal handler for the keyFocusOut signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #keyFocusOut callback

keyPressEvent

type ActorKeyPressEventCallback

Arguments

 = KeyEvent

event: a KeyEvent

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

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

Since: 0.6

afterActorKeyPressEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyPressEventCallback) -> m SignalHandlerId

Connect a signal handler for the keyPressEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #keyPressEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorKeyPressEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyPressEventCallback) -> m SignalHandlerId

Connect a signal handler for the keyPressEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #keyPressEvent callback

keyReleaseEvent

type ActorKeyReleaseEventCallback

Arguments

 = KeyEvent

event: a KeyEvent

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

The keyReleaseEvent signal is emitted each time a keyboard button is released while actor has key focus (see stageSetKeyFocus).

Since: 0.6

afterActorKeyReleaseEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyReleaseEventCallback) -> m SignalHandlerId

Connect a signal handler for the keyReleaseEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #keyReleaseEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorKeyReleaseEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyReleaseEventCallback) -> m SignalHandlerId

Connect a signal handler for the keyReleaseEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #keyReleaseEvent callback

leaveEvent

type ActorLeaveEventCallback

Arguments

 = CrossingEvent

event: a CrossingEvent

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

The leaveEvent signal is emitted when the pointer leaves the actor.

Since: 0.6

afterActorLeaveEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorLeaveEventCallback) -> m SignalHandlerId

Connect a signal handler for the leaveEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #leaveEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorLeaveEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorLeaveEventCallback) -> m SignalHandlerId

Connect a signal handler for the leaveEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #leaveEvent callback

motionEvent

type ActorMotionEventCallback

Arguments

 = MotionEvent

event: a MotionEvent

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

The motionEvent signal is emitted each time the mouse pointer is moved over actor.

Since: 0.6

afterActorMotionEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorMotionEventCallback) -> m SignalHandlerId

Connect a signal handler for the motionEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #motionEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorMotionEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorMotionEventCallback) -> m SignalHandlerId

Connect a signal handler for the motionEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #motionEvent callback

paint

type ActorPaintCallback = IO ()

Deprecated: (Since version 1.12)Override the ActorClass.paint virtual function, use a Content implementation, or a Effect instead of connecting to this signal.

The paint signal is emitted each time an actor is being painted.

Subclasses of Actor should override the ActorClass.paint virtual function paint themselves in that function.

It is strongly discouraged to connect a signal handler to the paint signal; if you want to change the paint sequence of an existing Actor instance, either create a new Actor class and override the ActorClass.paint virtual function, or use a Effect. The paint signal will be removed in a future version of Clutter.

Since: 0.8

afterActorPaint :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorPaintCallback) -> m SignalHandlerId

Connect a signal handler for the paint signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #paint callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorPaint :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorPaintCallback) -> m SignalHandlerId

Connect a signal handler for the paint signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #paint callback

parentSet

type ActorParentSetCallback

Arguments

 = Maybe Actor

oldParent: the previous parent of the actor, or Nothing

-> IO ()

This signal is emitted when the parent of the actor changes.

Since: 0.2

afterActorParentSet :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorParentSetCallback) -> m SignalHandlerId

Connect a signal handler for the parentSet signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #parentSet callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorParentSet :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorParentSetCallback) -> m SignalHandlerId

Connect a signal handler for the parentSet signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #parentSet callback

pick

type ActorPickCallback

Arguments

 = Color

color: the Color to be used when picking

-> IO ()

Deprecated: (Since version 1.12)Override the ActorClass.pick virtual function instead.

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 stageGetActorAtPos. The actor should paint its shape using the passed pickColor.

Subclasses of Actor should override the class signal handler and paint themselves in that function.

It is possible to connect a handler to the pick signal in order to set up some custom aspect of a paint in pick mode.

Since: 1.0

afterActorPick :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorPickCallback) -> m SignalHandlerId

Connect a signal handler for the pick signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #pick callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorPick :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorPickCallback) -> m SignalHandlerId

Connect a signal handler for the pick signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #pick callback

queueRedraw

type ActorQueueRedrawCallback

Arguments

 = Actor

origin: the actor which initiated the redraw request

-> IO ()

The queue_redraw signal is emitted when actorQueueRedraw is called on origin.

The default implementation for Actor chains up to the parent actor and queues a redraw on the parent, thus "bubbling" the redraw queue up through the actor graph. The default implementation for Stage queues a stageEnsureRedraw in a main loop idle handler.

Note that the origin actor may be the stage, or a container; it does not have to be a leaf node in the actor graph.

Toolkits embedding a Stage which require a redraw and relayout cycle can stop the emission of this signal using the GSignal API, redraw the UI and then call stageEnsureRedraw themselves, like:

C code

 static void
 on_redraw_complete (gpointer data)
 {
   ClutterStage *stage = data;

   // execute the Clutter drawing pipeline
   clutter_stage_ensure_redraw (stage);
 }

 static void
 on_stage_queue_redraw (ClutterStage *stage)
 {
   // this prevents the default handler to run
   g_signal_stop_emission_by_name (stage, "queue-redraw");

   // queue a redraw with the host toolkit and call
   // a function when the redraw has been completed
   queue_a_redraw (G_CALLBACK (on_redraw_complete), stage);
 }

Note: This signal is emitted before the Clutter paint pipeline is executed. If you want to know when the pipeline has been completed you should use threadsAddRepaintFunc or threadsAddRepaintFuncFull.

Since: 1.0

afterActorQueueRedraw :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorQueueRedrawCallback) -> m SignalHandlerId

Connect a signal handler for the queueRedraw signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #queueRedraw callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorQueueRedraw :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorQueueRedrawCallback) -> m SignalHandlerId

Connect a signal handler for the queueRedraw signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #queueRedraw callback

queueRelayout

type ActorQueueRelayoutCallback = IO ()

The queue_layout signal is emitted when actorQueueRelayout is called on an actor.

The default implementation for Actor 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 presence of Clone actors. Applications will not normally need to connect to this signal.

Since: 1.2

afterActorQueueRelayout :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorQueueRelayoutCallback) -> m SignalHandlerId

Connect a signal handler for the queueRelayout signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #queueRelayout callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorQueueRelayout :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorQueueRelayoutCallback) -> m SignalHandlerId

Connect a signal handler for the queueRelayout signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #queueRelayout callback

realize

type ActorRealizeCallback = IO ()

Deprecated: (Since version 1.16)The signal should not be used in newly written code

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

Since: 0.8

afterActorRealize :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorRealizeCallback) -> m SignalHandlerId

Connect a signal handler for the realize signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #realize callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorRealize :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorRealizeCallback) -> m SignalHandlerId

Connect a signal handler for the realize signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #realize callback

scrollEvent

type ActorScrollEventCallback

Arguments

 = ScrollEvent

event: a ScrollEvent

-> IO Bool

Returns: True if the event has been handled by the actor, or False to continue the emission.

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

Since: 0.6

afterActorScrollEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorScrollEventCallback) -> m SignalHandlerId

Connect a signal handler for the scrollEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #scrollEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorScrollEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorScrollEventCallback) -> m SignalHandlerId

Connect a signal handler for the scrollEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #scrollEvent callback

show

type ActorShowCallback = IO ()

The show signal is emitted when an actor is visible and rendered on the stage.

Since: 0.2

afterActorShow :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorShowCallback) -> m SignalHandlerId

Connect a signal handler for the show signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #show callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorShow :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorShowCallback) -> m SignalHandlerId

Connect a signal handler for the show signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #show callback

touchEvent

type ActorTouchEventCallback

Arguments

 = Event

event: a Event

-> IO Bool

Returns: EVENT_STOP if the event has been handled by the actor, or EVENT_PROPAGATE to continue the emission.

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

Since: 1.12

afterActorTouchEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorTouchEventCallback) -> m SignalHandlerId

Connect a signal handler for the touchEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #touchEvent callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorTouchEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorTouchEventCallback) -> m SignalHandlerId

Connect a signal handler for the touchEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #touchEvent callback

transitionStopped

type ActorTransitionStoppedCallback

Arguments

 = Text

name: the name of the transition

-> Bool

isFinished: whether the transition was finished, or stopped

-> IO ()

The transitionStopped 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 timelineStop, or it has been removed from the transitions applied on actor, using actorRemoveTransition.

Since: 1.12

afterActorTransitionStopped :: (IsActor a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => ActorTransitionStoppedCallback) -> m SignalHandlerId

Connect a signal handler for the transitionStopped signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #transitionStopped callback

This signal admits a optional parameter detail. If it's not Nothing, we will connect to “transition-stopped::detail” instead.

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorTransitionStopped :: (IsActor a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => ActorTransitionStoppedCallback) -> m SignalHandlerId

Connect a signal handler for the transitionStopped signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #transitionStopped callback

This signal admits a optional parameter detail. If it's not Nothing, we will connect to “transition-stopped::detail” instead.

transitionsCompleted

type ActorTransitionsCompletedCallback = IO ()

The transitionsCompleted signal is emitted once all transitions involving actor are complete.

Since: 1.10

afterActorTransitionsCompleted :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorTransitionsCompletedCallback) -> m SignalHandlerId

Connect a signal handler for the transitionsCompleted signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #transitionsCompleted callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorTransitionsCompleted :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorTransitionsCompletedCallback) -> m SignalHandlerId

Connect a signal handler for the transitionsCompleted signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #transitionsCompleted callback

unrealize

type ActorUnrealizeCallback = IO ()

Deprecated: (Since version 1.16)The signal should not be used in newly written code

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

Since: 0.8

afterActorUnrealize :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorUnrealizeCallback) -> m SignalHandlerId

Connect a signal handler for the unrealize signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after actor #unrealize callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onActorUnrealize :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorUnrealizeCallback) -> m SignalHandlerId

Connect a signal handler for the unrealize signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on actor #unrealize callback