{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Base class for actors.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Clutter.Objects.Actor
    ( 
#if defined(ENABLE_OVERLOADING)
    ActorGetAbsAllocationVerticesMethodInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
    ActorGetAllocationVerticesMethodInfo    ,
#endif
#if defined(ENABLE_OVERLOADING)
    ActorGetChildTransformMethodInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    ActorGetTransformMethodInfo             ,
#endif
#if defined(ENABLE_OVERLOADING)
    ActorGetTransformationMatrixMethodInfo  ,
#endif

-- * Exported types
    Actor(..)                               ,
    IsActor                                 ,
    toActor                                 ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addAction]("GI.Clutter.Objects.Actor#g:method:addAction"), [addActionWithName]("GI.Clutter.Objects.Actor#g:method:addActionWithName"), [addActor]("GI.Clutter.Interfaces.Container#g:method:addActor"), [addChild]("GI.Clutter.Objects.Actor#g:method:addChild"), [addConstraint]("GI.Clutter.Objects.Actor#g:method:addConstraint"), [addConstraintWithName]("GI.Clutter.Objects.Actor#g:method:addConstraintWithName"), [addEffect]("GI.Clutter.Objects.Actor#g:method:addEffect"), [addEffectWithName]("GI.Clutter.Objects.Actor#g:method:addEffectWithName"), [addTransition]("GI.Clutter.Objects.Actor#g:method:addTransition"), [allocate]("GI.Clutter.Objects.Actor#g:method:allocate"), [allocateAlignFill]("GI.Clutter.Objects.Actor#g:method:allocateAlignFill"), [allocateAvailableSize]("GI.Clutter.Objects.Actor#g:method:allocateAvailableSize"), [allocatePreferredSize]("GI.Clutter.Objects.Actor#g:method:allocatePreferredSize"), [animateProperty]("GI.Clutter.Interfaces.Animatable#g:method:animateProperty"), [animateWithAlphav]("GI.Clutter.Objects.Actor#g:method:animateWithAlphav"), [animateWithTimelinev]("GI.Clutter.Objects.Actor#g:method:animateWithTimelinev"), [animatev]("GI.Clutter.Objects.Actor#g:method:animatev"), [applyRelativeTransformToPoint]("GI.Clutter.Objects.Actor#g:method:applyRelativeTransformToPoint"), [applyTransformToPoint]("GI.Clutter.Objects.Actor#g:method:applyTransformToPoint"), [bindModel]("GI.Clutter.Objects.Actor#g:method:bindModel"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childGetProperty]("GI.Clutter.Interfaces.Container#g:method:childGetProperty"), [childNotify]("GI.Clutter.Interfaces.Container#g:method:childNotify"), [childSetProperty]("GI.Clutter.Interfaces.Container#g:method:childSetProperty"), [clearActions]("GI.Clutter.Objects.Actor#g:method:clearActions"), [clearConstraints]("GI.Clutter.Objects.Actor#g:method:clearConstraints"), [clearEffects]("GI.Clutter.Objects.Actor#g:method:clearEffects"), [contains]("GI.Clutter.Objects.Actor#g:method:contains"), [continuePaint]("GI.Clutter.Objects.Actor#g:method:continuePaint"), [createChildMeta]("GI.Clutter.Interfaces.Container#g:method:createChildMeta"), [createPangoContext]("GI.Clutter.Objects.Actor#g:method:createPangoContext"), [createPangoLayout]("GI.Clutter.Objects.Actor#g:method:createPangoLayout"), [destroy]("GI.Clutter.Objects.Actor#g:method:destroy"), [destroyAllChildren]("GI.Clutter.Objects.Actor#g:method:destroyAllChildren"), [destroyChildMeta]("GI.Clutter.Interfaces.Container#g:method:destroyChildMeta"), [detachAnimation]("GI.Clutter.Objects.Actor#g:method:detachAnimation"), [event]("GI.Clutter.Objects.Actor#g:method:event"), [findChildByName]("GI.Clutter.Interfaces.Container#g:method:findChildByName"), [findProperty]("GI.Clutter.Interfaces.Animatable#g:method:findProperty"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.Clutter.Interfaces.Container#g:method:foreach"), [foreachWithInternals]("GI.Clutter.Interfaces.Container#g:method:foreachWithInternals"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabKeyFocus]("GI.Clutter.Objects.Actor#g:method:grabKeyFocus"), [hasActions]("GI.Clutter.Objects.Actor#g:method:hasActions"), [hasAllocation]("GI.Clutter.Objects.Actor#g:method:hasAllocation"), [hasClip]("GI.Clutter.Objects.Actor#g:method:hasClip"), [hasConstraints]("GI.Clutter.Objects.Actor#g:method:hasConstraints"), [hasEffects]("GI.Clutter.Objects.Actor#g:method:hasEffects"), [hasKeyFocus]("GI.Clutter.Objects.Actor#g:method:hasKeyFocus"), [hasOverlaps]("GI.Clutter.Objects.Actor#g:method:hasOverlaps"), [hasPointer]("GI.Clutter.Objects.Actor#g:method:hasPointer"), [hide]("GI.Clutter.Objects.Actor#g:method:hide"), [hideAll]("GI.Clutter.Objects.Actor#g:method:hideAll"), [insertChildAbove]("GI.Clutter.Objects.Actor#g:method:insertChildAbove"), [insertChildAtIndex]("GI.Clutter.Objects.Actor#g:method:insertChildAtIndex"), [insertChildBelow]("GI.Clutter.Objects.Actor#g:method:insertChildBelow"), [interpolateValue]("GI.Clutter.Interfaces.Animatable#g:method:interpolateValue"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isInClonePaint]("GI.Clutter.Objects.Actor#g:method:isInClonePaint"), [isMapped]("GI.Clutter.Objects.Actor#g:method:isMapped"), [isRealized]("GI.Clutter.Objects.Actor#g:method:isRealized"), [isRotated]("GI.Clutter.Objects.Actor#g:method:isRotated"), [isScaled]("GI.Clutter.Objects.Actor#g:method:isScaled"), [isVisible]("GI.Clutter.Objects.Actor#g:method:isVisible"), [lower]("GI.Clutter.Objects.Actor#g:method:lower"), [lowerBottom]("GI.Clutter.Objects.Actor#g:method:lowerBottom"), [lowerChild]("GI.Clutter.Interfaces.Container#g:method:lowerChild"), [map]("GI.Clutter.Objects.Actor#g:method:map"), [moveAnchorPoint]("GI.Clutter.Objects.Actor#g:method:moveAnchorPoint"), [moveAnchorPointFromGravity]("GI.Clutter.Objects.Actor#g:method:moveAnchorPointFromGravity"), [moveBy]("GI.Clutter.Objects.Actor#g:method:moveBy"), [needsExpand]("GI.Clutter.Objects.Actor#g:method:needsExpand"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paint]("GI.Clutter.Objects.Actor#g:method:paint"), [parseCustomNode]("GI.Clutter.Interfaces.Scriptable#g:method:parseCustomNode"), [popInternal]("GI.Clutter.Objects.Actor#g:method:popInternal"), [pushInternal]("GI.Clutter.Objects.Actor#g:method:pushInternal"), [queueRedraw]("GI.Clutter.Objects.Actor#g:method:queueRedraw"), [queueRedrawWithClip]("GI.Clutter.Objects.Actor#g:method:queueRedrawWithClip"), [queueRelayout]("GI.Clutter.Objects.Actor#g:method:queueRelayout"), [raise]("GI.Clutter.Objects.Actor#g:method:raise"), [raiseChild]("GI.Clutter.Interfaces.Container#g:method:raiseChild"), [raiseTop]("GI.Clutter.Objects.Actor#g:method:raiseTop"), [realize]("GI.Clutter.Objects.Actor#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeAction]("GI.Clutter.Objects.Actor#g:method:removeAction"), [removeActionByName]("GI.Clutter.Objects.Actor#g:method:removeActionByName"), [removeActor]("GI.Clutter.Interfaces.Container#g:method:removeActor"), [removeAllChildren]("GI.Clutter.Objects.Actor#g:method:removeAllChildren"), [removeAllTransitions]("GI.Clutter.Objects.Actor#g:method:removeAllTransitions"), [removeChild]("GI.Clutter.Objects.Actor#g:method:removeChild"), [removeClip]("GI.Clutter.Objects.Actor#g:method:removeClip"), [removeConstraint]("GI.Clutter.Objects.Actor#g:method:removeConstraint"), [removeConstraintByName]("GI.Clutter.Objects.Actor#g:method:removeConstraintByName"), [removeEffect]("GI.Clutter.Objects.Actor#g:method:removeEffect"), [removeEffectByName]("GI.Clutter.Objects.Actor#g:method:removeEffectByName"), [removeTransition]("GI.Clutter.Objects.Actor#g:method:removeTransition"), [reparent]("GI.Clutter.Objects.Actor#g:method:reparent"), [replaceChild]("GI.Clutter.Objects.Actor#g:method:replaceChild"), [restoreEasingState]("GI.Clutter.Objects.Actor#g:method:restoreEasingState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [saveEasingState]("GI.Clutter.Objects.Actor#g:method:saveEasingState"), [shouldPickPaint]("GI.Clutter.Objects.Actor#g:method:shouldPickPaint"), [show]("GI.Clutter.Objects.Actor#g:method:show"), [showAll]("GI.Clutter.Objects.Actor#g:method:showAll"), [sortDepthOrder]("GI.Clutter.Interfaces.Container#g:method:sortDepthOrder"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [transformStagePoint]("GI.Clutter.Objects.Actor#g:method:transformStagePoint"), [unmap]("GI.Clutter.Objects.Actor#g:method:unmap"), [unparent]("GI.Clutter.Objects.Actor#g:method:unparent"), [unrealize]("GI.Clutter.Objects.Actor#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetFlags]("GI.Clutter.Objects.Actor#g:method:unsetFlags"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAbsAllocationVertices]("GI.Clutter.Objects.Actor#g:method:getAbsAllocationVertices"), [getAccessible]("GI.Clutter.Objects.Actor#g:method:getAccessible"), [getAction]("GI.Clutter.Objects.Actor#g:method:getAction"), [getActions]("GI.Clutter.Objects.Actor#g:method:getActions"), [getAllocationBox]("GI.Clutter.Objects.Actor#g:method:getAllocationBox"), [getAllocationGeometry]("GI.Clutter.Objects.Actor#g:method:getAllocationGeometry"), [getAllocationVertices]("GI.Clutter.Objects.Actor#g:method:getAllocationVertices"), [getAnchorPoint]("GI.Clutter.Objects.Actor#g:method:getAnchorPoint"), [getAnchorPointGravity]("GI.Clutter.Objects.Actor#g:method:getAnchorPointGravity"), [getAnimation]("GI.Clutter.Objects.Actor#g:method:getAnimation"), [getBackgroundColor]("GI.Clutter.Objects.Actor#g:method:getBackgroundColor"), [getChildAtIndex]("GI.Clutter.Objects.Actor#g:method:getChildAtIndex"), [getChildMeta]("GI.Clutter.Interfaces.Container#g:method:getChildMeta"), [getChildTransform]("GI.Clutter.Objects.Actor#g:method:getChildTransform"), [getChildren]("GI.Clutter.Objects.Actor#g:method:getChildren"), [getClip]("GI.Clutter.Objects.Actor#g:method:getClip"), [getClipToAllocation]("GI.Clutter.Objects.Actor#g:method:getClipToAllocation"), [getConstraint]("GI.Clutter.Objects.Actor#g:method:getConstraint"), [getConstraints]("GI.Clutter.Objects.Actor#g:method:getConstraints"), [getContent]("GI.Clutter.Objects.Actor#g:method:getContent"), [getContentBox]("GI.Clutter.Objects.Actor#g:method:getContentBox"), [getContentGravity]("GI.Clutter.Objects.Actor#g:method:getContentGravity"), [getContentRepeat]("GI.Clutter.Objects.Actor#g:method:getContentRepeat"), [getContentScalingFilters]("GI.Clutter.Objects.Actor#g:method:getContentScalingFilters"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDefaultPaintVolume]("GI.Clutter.Objects.Actor#g:method:getDefaultPaintVolume"), [getDepth]("GI.Clutter.Objects.Actor#g:method:getDepth"), [getEasingDelay]("GI.Clutter.Objects.Actor#g:method:getEasingDelay"), [getEasingDuration]("GI.Clutter.Objects.Actor#g:method:getEasingDuration"), [getEasingMode]("GI.Clutter.Objects.Actor#g:method:getEasingMode"), [getEffect]("GI.Clutter.Objects.Actor#g:method:getEffect"), [getEffects]("GI.Clutter.Objects.Actor#g:method:getEffects"), [getFirstChild]("GI.Clutter.Objects.Actor#g:method:getFirstChild"), [getFixedPositionSet]("GI.Clutter.Objects.Actor#g:method:getFixedPositionSet"), [getFlags]("GI.Clutter.Objects.Actor#g:method:getFlags"), [getGeometry]("GI.Clutter.Objects.Actor#g:method:getGeometry"), [getGid]("GI.Clutter.Objects.Actor#g:method:getGid"), [getHeight]("GI.Clutter.Objects.Actor#g:method:getHeight"), [getId]("GI.Clutter.Interfaces.Scriptable#g:method:getId"), [getInitialState]("GI.Clutter.Interfaces.Animatable#g:method:getInitialState"), [getLastChild]("GI.Clutter.Objects.Actor#g:method:getLastChild"), [getLayoutManager]("GI.Clutter.Objects.Actor#g:method:getLayoutManager"), [getMargin]("GI.Clutter.Objects.Actor#g:method:getMargin"), [getMarginBottom]("GI.Clutter.Objects.Actor#g:method:getMarginBottom"), [getMarginLeft]("GI.Clutter.Objects.Actor#g:method:getMarginLeft"), [getMarginRight]("GI.Clutter.Objects.Actor#g:method:getMarginRight"), [getMarginTop]("GI.Clutter.Objects.Actor#g:method:getMarginTop"), [getNChildren]("GI.Clutter.Objects.Actor#g:method:getNChildren"), [getName]("GI.Clutter.Objects.Actor#g:method:getName"), [getNextSibling]("GI.Clutter.Objects.Actor#g:method:getNextSibling"), [getOffscreenRedirect]("GI.Clutter.Objects.Actor#g:method:getOffscreenRedirect"), [getOpacity]("GI.Clutter.Objects.Actor#g:method:getOpacity"), [getPaintBox]("GI.Clutter.Objects.Actor#g:method:getPaintBox"), [getPaintOpacity]("GI.Clutter.Objects.Actor#g:method:getPaintOpacity"), [getPaintVisibility]("GI.Clutter.Objects.Actor#g:method:getPaintVisibility"), [getPaintVolume]("GI.Clutter.Objects.Actor#g:method:getPaintVolume"), [getPangoContext]("GI.Clutter.Objects.Actor#g:method:getPangoContext"), [getParent]("GI.Clutter.Objects.Actor#g:method:getParent"), [getPivotPoint]("GI.Clutter.Objects.Actor#g:method:getPivotPoint"), [getPivotPointZ]("GI.Clutter.Objects.Actor#g:method:getPivotPointZ"), [getPosition]("GI.Clutter.Objects.Actor#g:method:getPosition"), [getPreferredHeight]("GI.Clutter.Objects.Actor#g:method:getPreferredHeight"), [getPreferredSize]("GI.Clutter.Objects.Actor#g:method:getPreferredSize"), [getPreferredWidth]("GI.Clutter.Objects.Actor#g:method:getPreferredWidth"), [getPreviousSibling]("GI.Clutter.Objects.Actor#g:method:getPreviousSibling"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getReactive]("GI.Clutter.Objects.Actor#g:method:getReactive"), [getRequestMode]("GI.Clutter.Objects.Actor#g:method:getRequestMode"), [getRotation]("GI.Clutter.Objects.Actor#g:method:getRotation"), [getRotationAngle]("GI.Clutter.Objects.Actor#g:method:getRotationAngle"), [getScale]("GI.Clutter.Objects.Actor#g:method:getScale"), [getScaleCenter]("GI.Clutter.Objects.Actor#g:method:getScaleCenter"), [getScaleGravity]("GI.Clutter.Objects.Actor#g:method:getScaleGravity"), [getScaleZ]("GI.Clutter.Objects.Actor#g:method:getScaleZ"), [getShader]("GI.Clutter.Objects.Actor#g:method:getShader"), [getSize]("GI.Clutter.Objects.Actor#g:method:getSize"), [getStage]("GI.Clutter.Objects.Actor#g:method:getStage"), [getTextDirection]("GI.Clutter.Objects.Actor#g:method:getTextDirection"), [getTransform]("GI.Clutter.Objects.Actor#g:method:getTransform"), [getTransformationMatrix]("GI.Clutter.Objects.Actor#g:method:getTransformationMatrix"), [getTransformedPaintVolume]("GI.Clutter.Objects.Actor#g:method:getTransformedPaintVolume"), [getTransformedPosition]("GI.Clutter.Objects.Actor#g:method:getTransformedPosition"), [getTransformedSize]("GI.Clutter.Objects.Actor#g:method:getTransformedSize"), [getTransition]("GI.Clutter.Objects.Actor#g:method:getTransition"), [getTranslation]("GI.Clutter.Objects.Actor#g:method:getTranslation"), [getWidth]("GI.Clutter.Objects.Actor#g:method:getWidth"), [getX]("GI.Clutter.Objects.Actor#g:method:getX"), [getXAlign]("GI.Clutter.Objects.Actor#g:method:getXAlign"), [getXExpand]("GI.Clutter.Objects.Actor#g:method:getXExpand"), [getY]("GI.Clutter.Objects.Actor#g:method:getY"), [getYAlign]("GI.Clutter.Objects.Actor#g:method:getYAlign"), [getYExpand]("GI.Clutter.Objects.Actor#g:method:getYExpand"), [getZPosition]("GI.Clutter.Objects.Actor#g:method:getZPosition"), [getZRotationGravity]("GI.Clutter.Objects.Actor#g:method:getZRotationGravity").
-- 
-- ==== Setters
-- [setAllocation]("GI.Clutter.Objects.Actor#g:method:setAllocation"), [setAnchorPoint]("GI.Clutter.Objects.Actor#g:method:setAnchorPoint"), [setAnchorPointFromGravity]("GI.Clutter.Objects.Actor#g:method:setAnchorPointFromGravity"), [setBackgroundColor]("GI.Clutter.Objects.Actor#g:method:setBackgroundColor"), [setChildAboveSibling]("GI.Clutter.Objects.Actor#g:method:setChildAboveSibling"), [setChildAtIndex]("GI.Clutter.Objects.Actor#g:method:setChildAtIndex"), [setChildBelowSibling]("GI.Clutter.Objects.Actor#g:method:setChildBelowSibling"), [setChildTransform]("GI.Clutter.Objects.Actor#g:method:setChildTransform"), [setClip]("GI.Clutter.Objects.Actor#g:method:setClip"), [setClipToAllocation]("GI.Clutter.Objects.Actor#g:method:setClipToAllocation"), [setContent]("GI.Clutter.Objects.Actor#g:method:setContent"), [setContentGravity]("GI.Clutter.Objects.Actor#g:method:setContentGravity"), [setContentRepeat]("GI.Clutter.Objects.Actor#g:method:setContentRepeat"), [setContentScalingFilters]("GI.Clutter.Objects.Actor#g:method:setContentScalingFilters"), [setCustomProperty]("GI.Clutter.Interfaces.Scriptable#g:method:setCustomProperty"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDepth]("GI.Clutter.Objects.Actor#g:method:setDepth"), [setEasingDelay]("GI.Clutter.Objects.Actor#g:method:setEasingDelay"), [setEasingDuration]("GI.Clutter.Objects.Actor#g:method:setEasingDuration"), [setEasingMode]("GI.Clutter.Objects.Actor#g:method:setEasingMode"), [setFinalState]("GI.Clutter.Interfaces.Animatable#g:method:setFinalState"), [setFixedPositionSet]("GI.Clutter.Objects.Actor#g:method:setFixedPositionSet"), [setFlags]("GI.Clutter.Objects.Actor#g:method:setFlags"), [setGeometry]("GI.Clutter.Objects.Actor#g:method:setGeometry"), [setHeight]("GI.Clutter.Objects.Actor#g:method:setHeight"), [setId]("GI.Clutter.Interfaces.Scriptable#g:method:setId"), [setLayoutManager]("GI.Clutter.Objects.Actor#g:method:setLayoutManager"), [setMargin]("GI.Clutter.Objects.Actor#g:method:setMargin"), [setMarginBottom]("GI.Clutter.Objects.Actor#g:method:setMarginBottom"), [setMarginLeft]("GI.Clutter.Objects.Actor#g:method:setMarginLeft"), [setMarginRight]("GI.Clutter.Objects.Actor#g:method:setMarginRight"), [setMarginTop]("GI.Clutter.Objects.Actor#g:method:setMarginTop"), [setName]("GI.Clutter.Objects.Actor#g:method:setName"), [setOffscreenRedirect]("GI.Clutter.Objects.Actor#g:method:setOffscreenRedirect"), [setOpacity]("GI.Clutter.Objects.Actor#g:method:setOpacity"), [setParent]("GI.Clutter.Objects.Actor#g:method:setParent"), [setPivotPoint]("GI.Clutter.Objects.Actor#g:method:setPivotPoint"), [setPivotPointZ]("GI.Clutter.Objects.Actor#g:method:setPivotPointZ"), [setPosition]("GI.Clutter.Objects.Actor#g:method:setPosition"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReactive]("GI.Clutter.Objects.Actor#g:method:setReactive"), [setRequestMode]("GI.Clutter.Objects.Actor#g:method:setRequestMode"), [setRotation]("GI.Clutter.Objects.Actor#g:method:setRotation"), [setRotationAngle]("GI.Clutter.Objects.Actor#g:method:setRotationAngle"), [setScale]("GI.Clutter.Objects.Actor#g:method:setScale"), [setScaleFull]("GI.Clutter.Objects.Actor#g:method:setScaleFull"), [setScaleWithGravity]("GI.Clutter.Objects.Actor#g:method:setScaleWithGravity"), [setScaleZ]("GI.Clutter.Objects.Actor#g:method:setScaleZ"), [setShader]("GI.Clutter.Objects.Actor#g:method:setShader"), [setShaderParam]("GI.Clutter.Objects.Actor#g:method:setShaderParam"), [setShaderParamFloat]("GI.Clutter.Objects.Actor#g:method:setShaderParamFloat"), [setShaderParamInt]("GI.Clutter.Objects.Actor#g:method:setShaderParamInt"), [setSize]("GI.Clutter.Objects.Actor#g:method:setSize"), [setTextDirection]("GI.Clutter.Objects.Actor#g:method:setTextDirection"), [setTransform]("GI.Clutter.Objects.Actor#g:method:setTransform"), [setTranslation]("GI.Clutter.Objects.Actor#g:method:setTranslation"), [setWidth]("GI.Clutter.Objects.Actor#g:method:setWidth"), [setX]("GI.Clutter.Objects.Actor#g:method:setX"), [setXAlign]("GI.Clutter.Objects.Actor#g:method:setXAlign"), [setXExpand]("GI.Clutter.Objects.Actor#g:method:setXExpand"), [setY]("GI.Clutter.Objects.Actor#g:method:setY"), [setYAlign]("GI.Clutter.Objects.Actor#g:method:setYAlign"), [setYExpand]("GI.Clutter.Objects.Actor#g:method:setYExpand"), [setZPosition]("GI.Clutter.Objects.Actor#g:method:setZPosition"), [setZRotationFromGravity]("GI.Clutter.Objects.Actor#g:method:setZRotationFromGravity").

#if defined(ENABLE_OVERLOADING)
    ResolveActorMethod                      ,
#endif

-- ** addAction #method:addAction#

#if defined(ENABLE_OVERLOADING)
    ActorAddActionMethodInfo                ,
#endif
    actorAddAction                          ,


-- ** addActionWithName #method:addActionWithName#

#if defined(ENABLE_OVERLOADING)
    ActorAddActionWithNameMethodInfo        ,
#endif
    actorAddActionWithName                  ,


-- ** addChild #method:addChild#

#if defined(ENABLE_OVERLOADING)
    ActorAddChildMethodInfo                 ,
#endif
    actorAddChild                           ,


-- ** addConstraint #method:addConstraint#

#if defined(ENABLE_OVERLOADING)
    ActorAddConstraintMethodInfo            ,
#endif
    actorAddConstraint                      ,


-- ** addConstraintWithName #method:addConstraintWithName#

#if defined(ENABLE_OVERLOADING)
    ActorAddConstraintWithNameMethodInfo    ,
#endif
    actorAddConstraintWithName              ,


-- ** addEffect #method:addEffect#

#if defined(ENABLE_OVERLOADING)
    ActorAddEffectMethodInfo                ,
#endif
    actorAddEffect                          ,


-- ** addEffectWithName #method:addEffectWithName#

#if defined(ENABLE_OVERLOADING)
    ActorAddEffectWithNameMethodInfo        ,
#endif
    actorAddEffectWithName                  ,


-- ** addTransition #method:addTransition#

#if defined(ENABLE_OVERLOADING)
    ActorAddTransitionMethodInfo            ,
#endif
    actorAddTransition                      ,


-- ** allocate #method:allocate#

#if defined(ENABLE_OVERLOADING)
    ActorAllocateMethodInfo                 ,
#endif
    actorAllocate                           ,


-- ** allocateAlignFill #method:allocateAlignFill#

#if defined(ENABLE_OVERLOADING)
    ActorAllocateAlignFillMethodInfo        ,
#endif
    actorAllocateAlignFill                  ,


-- ** allocateAvailableSize #method:allocateAvailableSize#

#if defined(ENABLE_OVERLOADING)
    ActorAllocateAvailableSizeMethodInfo    ,
#endif
    actorAllocateAvailableSize              ,


-- ** allocatePreferredSize #method:allocatePreferredSize#

#if defined(ENABLE_OVERLOADING)
    ActorAllocatePreferredSizeMethodInfo    ,
#endif
    actorAllocatePreferredSize              ,


-- ** animateWithAlphav #method:animateWithAlphav#

#if defined(ENABLE_OVERLOADING)
    ActorAnimateWithAlphavMethodInfo        ,
#endif
    actorAnimateWithAlphav                  ,


-- ** animateWithTimelinev #method:animateWithTimelinev#

#if defined(ENABLE_OVERLOADING)
    ActorAnimateWithTimelinevMethodInfo     ,
#endif
    actorAnimateWithTimelinev               ,


-- ** animatev #method:animatev#

#if defined(ENABLE_OVERLOADING)
    ActorAnimatevMethodInfo                 ,
#endif
    actorAnimatev                           ,


-- ** applyRelativeTransformToPoint #method:applyRelativeTransformToPoint#

#if defined(ENABLE_OVERLOADING)
    ActorApplyRelativeTransformToPointMethodInfo,
#endif
    actorApplyRelativeTransformToPoint      ,


-- ** applyTransformToPoint #method:applyTransformToPoint#

#if defined(ENABLE_OVERLOADING)
    ActorApplyTransformToPointMethodInfo    ,
#endif
    actorApplyTransformToPoint              ,


-- ** bindModel #method:bindModel#

#if defined(ENABLE_OVERLOADING)
    ActorBindModelMethodInfo                ,
#endif
    actorBindModel                          ,


-- ** clearActions #method:clearActions#

#if defined(ENABLE_OVERLOADING)
    ActorClearActionsMethodInfo             ,
#endif
    actorClearActions                       ,


-- ** clearConstraints #method:clearConstraints#

#if defined(ENABLE_OVERLOADING)
    ActorClearConstraintsMethodInfo         ,
#endif
    actorClearConstraints                   ,


-- ** clearEffects #method:clearEffects#

#if defined(ENABLE_OVERLOADING)
    ActorClearEffectsMethodInfo             ,
#endif
    actorClearEffects                       ,


-- ** contains #method:contains#

#if defined(ENABLE_OVERLOADING)
    ActorContainsMethodInfo                 ,
#endif
    actorContains                           ,


-- ** continuePaint #method:continuePaint#

#if defined(ENABLE_OVERLOADING)
    ActorContinuePaintMethodInfo            ,
#endif
    actorContinuePaint                      ,


-- ** createPangoContext #method:createPangoContext#

#if defined(ENABLE_OVERLOADING)
    ActorCreatePangoContextMethodInfo       ,
#endif
    actorCreatePangoContext                 ,


-- ** createPangoLayout #method:createPangoLayout#

#if defined(ENABLE_OVERLOADING)
    ActorCreatePangoLayoutMethodInfo        ,
#endif
    actorCreatePangoLayout                  ,


-- ** destroy #method:destroy#

#if defined(ENABLE_OVERLOADING)
    ActorDestroyMethodInfo                  ,
#endif
    actorDestroy                            ,


-- ** destroyAllChildren #method:destroyAllChildren#

#if defined(ENABLE_OVERLOADING)
    ActorDestroyAllChildrenMethodInfo       ,
#endif
    actorDestroyAllChildren                 ,


-- ** detachAnimation #method:detachAnimation#

#if defined(ENABLE_OVERLOADING)
    ActorDetachAnimationMethodInfo          ,
#endif
    actorDetachAnimation                    ,


-- ** event #method:event#

#if defined(ENABLE_OVERLOADING)
    ActorEventMethodInfo                    ,
#endif
    actorEvent                              ,


-- ** getAccessible #method:getAccessible#

#if defined(ENABLE_OVERLOADING)
    ActorGetAccessibleMethodInfo            ,
#endif
    actorGetAccessible                      ,


-- ** getAction #method:getAction#

#if defined(ENABLE_OVERLOADING)
    ActorGetActionMethodInfo                ,
#endif
    actorGetAction                          ,


-- ** getActions #method:getActions#

#if defined(ENABLE_OVERLOADING)
    ActorGetActionsMethodInfo               ,
#endif
    actorGetActions                         ,


-- ** getAllocationBox #method:getAllocationBox#

#if defined(ENABLE_OVERLOADING)
    ActorGetAllocationBoxMethodInfo         ,
#endif
    actorGetAllocationBox                   ,


-- ** getAllocationGeometry #method:getAllocationGeometry#

#if defined(ENABLE_OVERLOADING)
    ActorGetAllocationGeometryMethodInfo    ,
#endif
    actorGetAllocationGeometry              ,


-- ** getAnchorPoint #method:getAnchorPoint#

#if defined(ENABLE_OVERLOADING)
    ActorGetAnchorPointMethodInfo           ,
#endif
    actorGetAnchorPoint                     ,


-- ** getAnchorPointGravity #method:getAnchorPointGravity#

#if defined(ENABLE_OVERLOADING)
    ActorGetAnchorPointGravityMethodInfo    ,
#endif
    actorGetAnchorPointGravity              ,


-- ** getAnimation #method:getAnimation#

#if defined(ENABLE_OVERLOADING)
    ActorGetAnimationMethodInfo             ,
#endif
    actorGetAnimation                       ,


-- ** getBackgroundColor #method:getBackgroundColor#

#if defined(ENABLE_OVERLOADING)
    ActorGetBackgroundColorMethodInfo       ,
#endif
    actorGetBackgroundColor                 ,


-- ** getChildAtIndex #method:getChildAtIndex#

#if defined(ENABLE_OVERLOADING)
    ActorGetChildAtIndexMethodInfo          ,
#endif
    actorGetChildAtIndex                    ,


-- ** getChildren #method:getChildren#

#if defined(ENABLE_OVERLOADING)
    ActorGetChildrenMethodInfo              ,
#endif
    actorGetChildren                        ,


-- ** getClip #method:getClip#

#if defined(ENABLE_OVERLOADING)
    ActorGetClipMethodInfo                  ,
#endif
    actorGetClip                            ,


-- ** getClipToAllocation #method:getClipToAllocation#

#if defined(ENABLE_OVERLOADING)
    ActorGetClipToAllocationMethodInfo      ,
#endif
    actorGetClipToAllocation                ,


-- ** getConstraint #method:getConstraint#

#if defined(ENABLE_OVERLOADING)
    ActorGetConstraintMethodInfo            ,
#endif
    actorGetConstraint                      ,


-- ** getConstraints #method:getConstraints#

#if defined(ENABLE_OVERLOADING)
    ActorGetConstraintsMethodInfo           ,
#endif
    actorGetConstraints                     ,


-- ** getContent #method:getContent#

#if defined(ENABLE_OVERLOADING)
    ActorGetContentMethodInfo               ,
#endif
    actorGetContent                         ,


-- ** getContentBox #method:getContentBox#

#if defined(ENABLE_OVERLOADING)
    ActorGetContentBoxMethodInfo            ,
#endif
    actorGetContentBox                      ,


-- ** getContentGravity #method:getContentGravity#

#if defined(ENABLE_OVERLOADING)
    ActorGetContentGravityMethodInfo        ,
#endif
    actorGetContentGravity                  ,


-- ** getContentRepeat #method:getContentRepeat#

#if defined(ENABLE_OVERLOADING)
    ActorGetContentRepeatMethodInfo         ,
#endif
    actorGetContentRepeat                   ,


-- ** getContentScalingFilters #method:getContentScalingFilters#

#if defined(ENABLE_OVERLOADING)
    ActorGetContentScalingFiltersMethodInfo ,
#endif
    actorGetContentScalingFilters           ,


-- ** getDefaultPaintVolume #method:getDefaultPaintVolume#

#if defined(ENABLE_OVERLOADING)
    ActorGetDefaultPaintVolumeMethodInfo    ,
#endif
    actorGetDefaultPaintVolume              ,


-- ** getDepth #method:getDepth#

#if defined(ENABLE_OVERLOADING)
    ActorGetDepthMethodInfo                 ,
#endif
    actorGetDepth                           ,


-- ** getEasingDelay #method:getEasingDelay#

#if defined(ENABLE_OVERLOADING)
    ActorGetEasingDelayMethodInfo           ,
#endif
    actorGetEasingDelay                     ,


-- ** getEasingDuration #method:getEasingDuration#

#if defined(ENABLE_OVERLOADING)
    ActorGetEasingDurationMethodInfo        ,
#endif
    actorGetEasingDuration                  ,


-- ** getEasingMode #method:getEasingMode#

#if defined(ENABLE_OVERLOADING)
    ActorGetEasingModeMethodInfo            ,
#endif
    actorGetEasingMode                      ,


-- ** getEffect #method:getEffect#

#if defined(ENABLE_OVERLOADING)
    ActorGetEffectMethodInfo                ,
#endif
    actorGetEffect                          ,


-- ** getEffects #method:getEffects#

#if defined(ENABLE_OVERLOADING)
    ActorGetEffectsMethodInfo               ,
#endif
    actorGetEffects                         ,


-- ** getFirstChild #method:getFirstChild#

#if defined(ENABLE_OVERLOADING)
    ActorGetFirstChildMethodInfo            ,
#endif
    actorGetFirstChild                      ,


-- ** getFixedPositionSet #method:getFixedPositionSet#

#if defined(ENABLE_OVERLOADING)
    ActorGetFixedPositionSetMethodInfo      ,
#endif
    actorGetFixedPositionSet                ,


-- ** getFlags #method:getFlags#

#if defined(ENABLE_OVERLOADING)
    ActorGetFlagsMethodInfo                 ,
#endif
    actorGetFlags                           ,


-- ** getGeometry #method:getGeometry#

#if defined(ENABLE_OVERLOADING)
    ActorGetGeometryMethodInfo              ,
#endif
    actorGetGeometry                        ,


-- ** getGid #method:getGid#

#if defined(ENABLE_OVERLOADING)
    ActorGetGidMethodInfo                   ,
#endif
    actorGetGid                             ,


-- ** getHeight #method:getHeight#

#if defined(ENABLE_OVERLOADING)
    ActorGetHeightMethodInfo                ,
#endif
    actorGetHeight                          ,


-- ** getLastChild #method:getLastChild#

#if defined(ENABLE_OVERLOADING)
    ActorGetLastChildMethodInfo             ,
#endif
    actorGetLastChild                       ,


-- ** getLayoutManager #method:getLayoutManager#

#if defined(ENABLE_OVERLOADING)
    ActorGetLayoutManagerMethodInfo         ,
#endif
    actorGetLayoutManager                   ,


-- ** getMargin #method:getMargin#

#if defined(ENABLE_OVERLOADING)
    ActorGetMarginMethodInfo                ,
#endif
    actorGetMargin                          ,


-- ** getMarginBottom #method:getMarginBottom#

#if defined(ENABLE_OVERLOADING)
    ActorGetMarginBottomMethodInfo          ,
#endif
    actorGetMarginBottom                    ,


-- ** getMarginLeft #method:getMarginLeft#

#if defined(ENABLE_OVERLOADING)
    ActorGetMarginLeftMethodInfo            ,
#endif
    actorGetMarginLeft                      ,


-- ** getMarginRight #method:getMarginRight#

#if defined(ENABLE_OVERLOADING)
    ActorGetMarginRightMethodInfo           ,
#endif
    actorGetMarginRight                     ,


-- ** getMarginTop #method:getMarginTop#

#if defined(ENABLE_OVERLOADING)
    ActorGetMarginTopMethodInfo             ,
#endif
    actorGetMarginTop                       ,


-- ** getNChildren #method:getNChildren#

#if defined(ENABLE_OVERLOADING)
    ActorGetNChildrenMethodInfo             ,
#endif
    actorGetNChildren                       ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    ActorGetNameMethodInfo                  ,
#endif
    actorGetName                            ,


-- ** getNextSibling #method:getNextSibling#

#if defined(ENABLE_OVERLOADING)
    ActorGetNextSiblingMethodInfo           ,
#endif
    actorGetNextSibling                     ,


-- ** getOffscreenRedirect #method:getOffscreenRedirect#

#if defined(ENABLE_OVERLOADING)
    ActorGetOffscreenRedirectMethodInfo     ,
#endif
    actorGetOffscreenRedirect               ,


-- ** getOpacity #method:getOpacity#

#if defined(ENABLE_OVERLOADING)
    ActorGetOpacityMethodInfo               ,
#endif
    actorGetOpacity                         ,


-- ** getPaintBox #method:getPaintBox#

#if defined(ENABLE_OVERLOADING)
    ActorGetPaintBoxMethodInfo              ,
#endif
    actorGetPaintBox                        ,


-- ** getPaintOpacity #method:getPaintOpacity#

#if defined(ENABLE_OVERLOADING)
    ActorGetPaintOpacityMethodInfo          ,
#endif
    actorGetPaintOpacity                    ,


-- ** getPaintVisibility #method:getPaintVisibility#

#if defined(ENABLE_OVERLOADING)
    ActorGetPaintVisibilityMethodInfo       ,
#endif
    actorGetPaintVisibility                 ,


-- ** getPaintVolume #method:getPaintVolume#

#if defined(ENABLE_OVERLOADING)
    ActorGetPaintVolumeMethodInfo           ,
#endif
    actorGetPaintVolume                     ,


-- ** getPangoContext #method:getPangoContext#

#if defined(ENABLE_OVERLOADING)
    ActorGetPangoContextMethodInfo          ,
#endif
    actorGetPangoContext                    ,


-- ** getParent #method:getParent#

#if defined(ENABLE_OVERLOADING)
    ActorGetParentMethodInfo                ,
#endif
    actorGetParent                          ,


-- ** getPivotPoint #method:getPivotPoint#

#if defined(ENABLE_OVERLOADING)
    ActorGetPivotPointMethodInfo            ,
#endif
    actorGetPivotPoint                      ,


-- ** getPivotPointZ #method:getPivotPointZ#

#if defined(ENABLE_OVERLOADING)
    ActorGetPivotPointZMethodInfo           ,
#endif
    actorGetPivotPointZ                     ,


-- ** getPosition #method:getPosition#

#if defined(ENABLE_OVERLOADING)
    ActorGetPositionMethodInfo              ,
#endif
    actorGetPosition                        ,


-- ** getPreferredHeight #method:getPreferredHeight#

#if defined(ENABLE_OVERLOADING)
    ActorGetPreferredHeightMethodInfo       ,
#endif
    actorGetPreferredHeight                 ,


-- ** getPreferredSize #method:getPreferredSize#

#if defined(ENABLE_OVERLOADING)
    ActorGetPreferredSizeMethodInfo         ,
#endif
    actorGetPreferredSize                   ,


-- ** getPreferredWidth #method:getPreferredWidth#

#if defined(ENABLE_OVERLOADING)
    ActorGetPreferredWidthMethodInfo        ,
#endif
    actorGetPreferredWidth                  ,


-- ** getPreviousSibling #method:getPreviousSibling#

#if defined(ENABLE_OVERLOADING)
    ActorGetPreviousSiblingMethodInfo       ,
#endif
    actorGetPreviousSibling                 ,


-- ** getReactive #method:getReactive#

#if defined(ENABLE_OVERLOADING)
    ActorGetReactiveMethodInfo              ,
#endif
    actorGetReactive                        ,


-- ** getRequestMode #method:getRequestMode#

#if defined(ENABLE_OVERLOADING)
    ActorGetRequestModeMethodInfo           ,
#endif
    actorGetRequestMode                     ,


-- ** getRotation #method:getRotation#

#if defined(ENABLE_OVERLOADING)
    ActorGetRotationMethodInfo              ,
#endif
    actorGetRotation                        ,


-- ** getRotationAngle #method:getRotationAngle#

#if defined(ENABLE_OVERLOADING)
    ActorGetRotationAngleMethodInfo         ,
#endif
    actorGetRotationAngle                   ,


-- ** getScale #method:getScale#

#if defined(ENABLE_OVERLOADING)
    ActorGetScaleMethodInfo                 ,
#endif
    actorGetScale                           ,


-- ** getScaleCenter #method:getScaleCenter#

#if defined(ENABLE_OVERLOADING)
    ActorGetScaleCenterMethodInfo           ,
#endif
    actorGetScaleCenter                     ,


-- ** getScaleGravity #method:getScaleGravity#

#if defined(ENABLE_OVERLOADING)
    ActorGetScaleGravityMethodInfo          ,
#endif
    actorGetScaleGravity                    ,


-- ** getScaleZ #method:getScaleZ#

#if defined(ENABLE_OVERLOADING)
    ActorGetScaleZMethodInfo                ,
#endif
    actorGetScaleZ                          ,


-- ** getShader #method:getShader#

#if defined(ENABLE_OVERLOADING)
    ActorGetShaderMethodInfo                ,
#endif
    actorGetShader                          ,


-- ** getSize #method:getSize#

#if defined(ENABLE_OVERLOADING)
    ActorGetSizeMethodInfo                  ,
#endif
    actorGetSize                            ,


-- ** getStage #method:getStage#

#if defined(ENABLE_OVERLOADING)
    ActorGetStageMethodInfo                 ,
#endif
    actorGetStage                           ,


-- ** getTextDirection #method:getTextDirection#

#if defined(ENABLE_OVERLOADING)
    ActorGetTextDirectionMethodInfo         ,
#endif
    actorGetTextDirection                   ,


-- ** getTransformedPaintVolume #method:getTransformedPaintVolume#

#if defined(ENABLE_OVERLOADING)
    ActorGetTransformedPaintVolumeMethodInfo,
#endif
    actorGetTransformedPaintVolume          ,


-- ** getTransformedPosition #method:getTransformedPosition#

#if defined(ENABLE_OVERLOADING)
    ActorGetTransformedPositionMethodInfo   ,
#endif
    actorGetTransformedPosition             ,


-- ** getTransformedSize #method:getTransformedSize#

#if defined(ENABLE_OVERLOADING)
    ActorGetTransformedSizeMethodInfo       ,
#endif
    actorGetTransformedSize                 ,


-- ** getTransition #method:getTransition#

#if defined(ENABLE_OVERLOADING)
    ActorGetTransitionMethodInfo            ,
#endif
    actorGetTransition                      ,


-- ** getTranslation #method:getTranslation#

#if defined(ENABLE_OVERLOADING)
    ActorGetTranslationMethodInfo           ,
#endif
    actorGetTranslation                     ,


-- ** getWidth #method:getWidth#

#if defined(ENABLE_OVERLOADING)
    ActorGetWidthMethodInfo                 ,
#endif
    actorGetWidth                           ,


-- ** getX #method:getX#

#if defined(ENABLE_OVERLOADING)
    ActorGetXMethodInfo                     ,
#endif
    actorGetX                               ,


-- ** getXAlign #method:getXAlign#

#if defined(ENABLE_OVERLOADING)
    ActorGetXAlignMethodInfo                ,
#endif
    actorGetXAlign                          ,


-- ** getXExpand #method:getXExpand#

#if defined(ENABLE_OVERLOADING)
    ActorGetXExpandMethodInfo               ,
#endif
    actorGetXExpand                         ,


-- ** getY #method:getY#

#if defined(ENABLE_OVERLOADING)
    ActorGetYMethodInfo                     ,
#endif
    actorGetY                               ,


-- ** getYAlign #method:getYAlign#

#if defined(ENABLE_OVERLOADING)
    ActorGetYAlignMethodInfo                ,
#endif
    actorGetYAlign                          ,


-- ** getYExpand #method:getYExpand#

#if defined(ENABLE_OVERLOADING)
    ActorGetYExpandMethodInfo               ,
#endif
    actorGetYExpand                         ,


-- ** getZPosition #method:getZPosition#

#if defined(ENABLE_OVERLOADING)
    ActorGetZPositionMethodInfo             ,
#endif
    actorGetZPosition                       ,


-- ** getZRotationGravity #method:getZRotationGravity#

#if defined(ENABLE_OVERLOADING)
    ActorGetZRotationGravityMethodInfo      ,
#endif
    actorGetZRotationGravity                ,


-- ** grabKeyFocus #method:grabKeyFocus#

#if defined(ENABLE_OVERLOADING)
    ActorGrabKeyFocusMethodInfo             ,
#endif
    actorGrabKeyFocus                       ,


-- ** hasActions #method:hasActions#

#if defined(ENABLE_OVERLOADING)
    ActorHasActionsMethodInfo               ,
#endif
    actorHasActions                         ,


-- ** hasAllocation #method:hasAllocation#

#if defined(ENABLE_OVERLOADING)
    ActorHasAllocationMethodInfo            ,
#endif
    actorHasAllocation                      ,


-- ** hasClip #method:hasClip#

#if defined(ENABLE_OVERLOADING)
    ActorHasClipMethodInfo                  ,
#endif
    actorHasClip                            ,


-- ** hasConstraints #method:hasConstraints#

#if defined(ENABLE_OVERLOADING)
    ActorHasConstraintsMethodInfo           ,
#endif
    actorHasConstraints                     ,


-- ** hasEffects #method:hasEffects#

#if defined(ENABLE_OVERLOADING)
    ActorHasEffectsMethodInfo               ,
#endif
    actorHasEffects                         ,


-- ** hasKeyFocus #method:hasKeyFocus#

#if defined(ENABLE_OVERLOADING)
    ActorHasKeyFocusMethodInfo              ,
#endif
    actorHasKeyFocus                        ,


-- ** hasOverlaps #method:hasOverlaps#

#if defined(ENABLE_OVERLOADING)
    ActorHasOverlapsMethodInfo              ,
#endif
    actorHasOverlaps                        ,


-- ** hasPointer #method:hasPointer#

#if defined(ENABLE_OVERLOADING)
    ActorHasPointerMethodInfo               ,
#endif
    actorHasPointer                         ,


-- ** hide #method:hide#

#if defined(ENABLE_OVERLOADING)
    ActorHideMethodInfo                     ,
#endif
    actorHide                               ,


-- ** hideAll #method:hideAll#

#if defined(ENABLE_OVERLOADING)
    ActorHideAllMethodInfo                  ,
#endif
    actorHideAll                            ,


-- ** insertChildAbove #method:insertChildAbove#

#if defined(ENABLE_OVERLOADING)
    ActorInsertChildAboveMethodInfo         ,
#endif
    actorInsertChildAbove                   ,


-- ** insertChildAtIndex #method:insertChildAtIndex#

#if defined(ENABLE_OVERLOADING)
    ActorInsertChildAtIndexMethodInfo       ,
#endif
    actorInsertChildAtIndex                 ,


-- ** insertChildBelow #method:insertChildBelow#

#if defined(ENABLE_OVERLOADING)
    ActorInsertChildBelowMethodInfo         ,
#endif
    actorInsertChildBelow                   ,


-- ** isInClonePaint #method:isInClonePaint#

#if defined(ENABLE_OVERLOADING)
    ActorIsInClonePaintMethodInfo           ,
#endif
    actorIsInClonePaint                     ,


-- ** isMapped #method:isMapped#

#if defined(ENABLE_OVERLOADING)
    ActorIsMappedMethodInfo                 ,
#endif
    actorIsMapped                           ,


-- ** isRealized #method:isRealized#

#if defined(ENABLE_OVERLOADING)
    ActorIsRealizedMethodInfo               ,
#endif
    actorIsRealized                         ,


-- ** isRotated #method:isRotated#

#if defined(ENABLE_OVERLOADING)
    ActorIsRotatedMethodInfo                ,
#endif
    actorIsRotated                          ,


-- ** isScaled #method:isScaled#

#if defined(ENABLE_OVERLOADING)
    ActorIsScaledMethodInfo                 ,
#endif
    actorIsScaled                           ,


-- ** isVisible #method:isVisible#

#if defined(ENABLE_OVERLOADING)
    ActorIsVisibleMethodInfo                ,
#endif
    actorIsVisible                          ,


-- ** lower #method:lower#

#if defined(ENABLE_OVERLOADING)
    ActorLowerMethodInfo                    ,
#endif
    actorLower                              ,


-- ** lowerBottom #method:lowerBottom#

#if defined(ENABLE_OVERLOADING)
    ActorLowerBottomMethodInfo              ,
#endif
    actorLowerBottom                        ,


-- ** map #method:map#

#if defined(ENABLE_OVERLOADING)
    ActorMapMethodInfo                      ,
#endif
    actorMap                                ,


-- ** moveAnchorPoint #method:moveAnchorPoint#

#if defined(ENABLE_OVERLOADING)
    ActorMoveAnchorPointMethodInfo          ,
#endif
    actorMoveAnchorPoint                    ,


-- ** moveAnchorPointFromGravity #method:moveAnchorPointFromGravity#

#if defined(ENABLE_OVERLOADING)
    ActorMoveAnchorPointFromGravityMethodInfo,
#endif
    actorMoveAnchorPointFromGravity         ,


-- ** moveBy #method:moveBy#

#if defined(ENABLE_OVERLOADING)
    ActorMoveByMethodInfo                   ,
#endif
    actorMoveBy                             ,


-- ** needsExpand #method:needsExpand#

#if defined(ENABLE_OVERLOADING)
    ActorNeedsExpandMethodInfo              ,
#endif
    actorNeedsExpand                        ,


-- ** new #method:new#

    actorNew                                ,


-- ** paint #method:paint#

#if defined(ENABLE_OVERLOADING)
    ActorPaintMethodInfo                    ,
#endif
    actorPaint                              ,


-- ** popInternal #method:popInternal#

#if defined(ENABLE_OVERLOADING)
    ActorPopInternalMethodInfo              ,
#endif
    actorPopInternal                        ,


-- ** pushInternal #method:pushInternal#

#if defined(ENABLE_OVERLOADING)
    ActorPushInternalMethodInfo             ,
#endif
    actorPushInternal                       ,


-- ** queueRedraw #method:queueRedraw#

#if defined(ENABLE_OVERLOADING)
    ActorQueueRedrawMethodInfo              ,
#endif
    actorQueueRedraw                        ,


-- ** queueRedrawWithClip #method:queueRedrawWithClip#

#if defined(ENABLE_OVERLOADING)
    ActorQueueRedrawWithClipMethodInfo      ,
#endif
    actorQueueRedrawWithClip                ,


-- ** queueRelayout #method:queueRelayout#

#if defined(ENABLE_OVERLOADING)
    ActorQueueRelayoutMethodInfo            ,
#endif
    actorQueueRelayout                      ,


-- ** raise #method:raise#

#if defined(ENABLE_OVERLOADING)
    ActorRaiseMethodInfo                    ,
#endif
    actorRaise                              ,


-- ** raiseTop #method:raiseTop#

#if defined(ENABLE_OVERLOADING)
    ActorRaiseTopMethodInfo                 ,
#endif
    actorRaiseTop                           ,


-- ** realize #method:realize#

#if defined(ENABLE_OVERLOADING)
    ActorRealizeMethodInfo                  ,
#endif
    actorRealize                            ,


-- ** removeAction #method:removeAction#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveActionMethodInfo             ,
#endif
    actorRemoveAction                       ,


-- ** removeActionByName #method:removeActionByName#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveActionByNameMethodInfo       ,
#endif
    actorRemoveActionByName                 ,


-- ** removeAllChildren #method:removeAllChildren#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveAllChildrenMethodInfo        ,
#endif
    actorRemoveAllChildren                  ,


-- ** removeAllTransitions #method:removeAllTransitions#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveAllTransitionsMethodInfo     ,
#endif
    actorRemoveAllTransitions               ,


-- ** removeChild #method:removeChild#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveChildMethodInfo              ,
#endif
    actorRemoveChild                        ,


-- ** removeClip #method:removeClip#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveClipMethodInfo               ,
#endif
    actorRemoveClip                         ,


-- ** removeConstraint #method:removeConstraint#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveConstraintMethodInfo         ,
#endif
    actorRemoveConstraint                   ,


-- ** removeConstraintByName #method:removeConstraintByName#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveConstraintByNameMethodInfo   ,
#endif
    actorRemoveConstraintByName             ,


-- ** removeEffect #method:removeEffect#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveEffectMethodInfo             ,
#endif
    actorRemoveEffect                       ,


-- ** removeEffectByName #method:removeEffectByName#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveEffectByNameMethodInfo       ,
#endif
    actorRemoveEffectByName                 ,


-- ** removeTransition #method:removeTransition#

#if defined(ENABLE_OVERLOADING)
    ActorRemoveTransitionMethodInfo         ,
#endif
    actorRemoveTransition                   ,


-- ** reparent #method:reparent#

#if defined(ENABLE_OVERLOADING)
    ActorReparentMethodInfo                 ,
#endif
    actorReparent                           ,


-- ** replaceChild #method:replaceChild#

#if defined(ENABLE_OVERLOADING)
    ActorReplaceChildMethodInfo             ,
#endif
    actorReplaceChild                       ,


-- ** restoreEasingState #method:restoreEasingState#

#if defined(ENABLE_OVERLOADING)
    ActorRestoreEasingStateMethodInfo       ,
#endif
    actorRestoreEasingState                 ,


-- ** saveEasingState #method:saveEasingState#

#if defined(ENABLE_OVERLOADING)
    ActorSaveEasingStateMethodInfo          ,
#endif
    actorSaveEasingState                    ,


-- ** setAllocation #method:setAllocation#

#if defined(ENABLE_OVERLOADING)
    ActorSetAllocationMethodInfo            ,
#endif
    actorSetAllocation                      ,


-- ** setAnchorPoint #method:setAnchorPoint#

#if defined(ENABLE_OVERLOADING)
    ActorSetAnchorPointMethodInfo           ,
#endif
    actorSetAnchorPoint                     ,


-- ** setAnchorPointFromGravity #method:setAnchorPointFromGravity#

#if defined(ENABLE_OVERLOADING)
    ActorSetAnchorPointFromGravityMethodInfo,
#endif
    actorSetAnchorPointFromGravity          ,


-- ** setBackgroundColor #method:setBackgroundColor#

#if defined(ENABLE_OVERLOADING)
    ActorSetBackgroundColorMethodInfo       ,
#endif
    actorSetBackgroundColor                 ,


-- ** setChildAboveSibling #method:setChildAboveSibling#

#if defined(ENABLE_OVERLOADING)
    ActorSetChildAboveSiblingMethodInfo     ,
#endif
    actorSetChildAboveSibling               ,


-- ** setChildAtIndex #method:setChildAtIndex#

#if defined(ENABLE_OVERLOADING)
    ActorSetChildAtIndexMethodInfo          ,
#endif
    actorSetChildAtIndex                    ,


-- ** setChildBelowSibling #method:setChildBelowSibling#

#if defined(ENABLE_OVERLOADING)
    ActorSetChildBelowSiblingMethodInfo     ,
#endif
    actorSetChildBelowSibling               ,


-- ** setChildTransform #method:setChildTransform#

#if defined(ENABLE_OVERLOADING)
    ActorSetChildTransformMethodInfo        ,
#endif
    actorSetChildTransform                  ,


-- ** setClip #method:setClip#

#if defined(ENABLE_OVERLOADING)
    ActorSetClipMethodInfo                  ,
#endif
    actorSetClip                            ,


-- ** setClipToAllocation #method:setClipToAllocation#

#if defined(ENABLE_OVERLOADING)
    ActorSetClipToAllocationMethodInfo      ,
#endif
    actorSetClipToAllocation                ,


-- ** setContent #method:setContent#

#if defined(ENABLE_OVERLOADING)
    ActorSetContentMethodInfo               ,
#endif
    actorSetContent                         ,


-- ** setContentGravity #method:setContentGravity#

#if defined(ENABLE_OVERLOADING)
    ActorSetContentGravityMethodInfo        ,
#endif
    actorSetContentGravity                  ,


-- ** setContentRepeat #method:setContentRepeat#

#if defined(ENABLE_OVERLOADING)
    ActorSetContentRepeatMethodInfo         ,
#endif
    actorSetContentRepeat                   ,


-- ** setContentScalingFilters #method:setContentScalingFilters#

#if defined(ENABLE_OVERLOADING)
    ActorSetContentScalingFiltersMethodInfo ,
#endif
    actorSetContentScalingFilters           ,


-- ** setDepth #method:setDepth#

#if defined(ENABLE_OVERLOADING)
    ActorSetDepthMethodInfo                 ,
#endif
    actorSetDepth                           ,


-- ** setEasingDelay #method:setEasingDelay#

#if defined(ENABLE_OVERLOADING)
    ActorSetEasingDelayMethodInfo           ,
#endif
    actorSetEasingDelay                     ,


-- ** setEasingDuration #method:setEasingDuration#

#if defined(ENABLE_OVERLOADING)
    ActorSetEasingDurationMethodInfo        ,
#endif
    actorSetEasingDuration                  ,


-- ** setEasingMode #method:setEasingMode#

#if defined(ENABLE_OVERLOADING)
    ActorSetEasingModeMethodInfo            ,
#endif
    actorSetEasingMode                      ,


-- ** setFixedPositionSet #method:setFixedPositionSet#

#if defined(ENABLE_OVERLOADING)
    ActorSetFixedPositionSetMethodInfo      ,
#endif
    actorSetFixedPositionSet                ,


-- ** setFlags #method:setFlags#

#if defined(ENABLE_OVERLOADING)
    ActorSetFlagsMethodInfo                 ,
#endif
    actorSetFlags                           ,


-- ** setGeometry #method:setGeometry#

#if defined(ENABLE_OVERLOADING)
    ActorSetGeometryMethodInfo              ,
#endif
    actorSetGeometry                        ,


-- ** setHeight #method:setHeight#

#if defined(ENABLE_OVERLOADING)
    ActorSetHeightMethodInfo                ,
#endif
    actorSetHeight                          ,


-- ** setLayoutManager #method:setLayoutManager#

#if defined(ENABLE_OVERLOADING)
    ActorSetLayoutManagerMethodInfo         ,
#endif
    actorSetLayoutManager                   ,


-- ** setMargin #method:setMargin#

#if defined(ENABLE_OVERLOADING)
    ActorSetMarginMethodInfo                ,
#endif
    actorSetMargin                          ,


-- ** setMarginBottom #method:setMarginBottom#

#if defined(ENABLE_OVERLOADING)
    ActorSetMarginBottomMethodInfo          ,
#endif
    actorSetMarginBottom                    ,


-- ** setMarginLeft #method:setMarginLeft#

#if defined(ENABLE_OVERLOADING)
    ActorSetMarginLeftMethodInfo            ,
#endif
    actorSetMarginLeft                      ,


-- ** setMarginRight #method:setMarginRight#

#if defined(ENABLE_OVERLOADING)
    ActorSetMarginRightMethodInfo           ,
#endif
    actorSetMarginRight                     ,


-- ** setMarginTop #method:setMarginTop#

#if defined(ENABLE_OVERLOADING)
    ActorSetMarginTopMethodInfo             ,
#endif
    actorSetMarginTop                       ,


-- ** setName #method:setName#

#if defined(ENABLE_OVERLOADING)
    ActorSetNameMethodInfo                  ,
#endif
    actorSetName                            ,


-- ** setOffscreenRedirect #method:setOffscreenRedirect#

#if defined(ENABLE_OVERLOADING)
    ActorSetOffscreenRedirectMethodInfo     ,
#endif
    actorSetOffscreenRedirect               ,


-- ** setOpacity #method:setOpacity#

#if defined(ENABLE_OVERLOADING)
    ActorSetOpacityMethodInfo               ,
#endif
    actorSetOpacity                         ,


-- ** setParent #method:setParent#

#if defined(ENABLE_OVERLOADING)
    ActorSetParentMethodInfo                ,
#endif
    actorSetParent                          ,


-- ** setPivotPoint #method:setPivotPoint#

#if defined(ENABLE_OVERLOADING)
    ActorSetPivotPointMethodInfo            ,
#endif
    actorSetPivotPoint                      ,


-- ** setPivotPointZ #method:setPivotPointZ#

#if defined(ENABLE_OVERLOADING)
    ActorSetPivotPointZMethodInfo           ,
#endif
    actorSetPivotPointZ                     ,


-- ** setPosition #method:setPosition#

#if defined(ENABLE_OVERLOADING)
    ActorSetPositionMethodInfo              ,
#endif
    actorSetPosition                        ,


-- ** setReactive #method:setReactive#

#if defined(ENABLE_OVERLOADING)
    ActorSetReactiveMethodInfo              ,
#endif
    actorSetReactive                        ,


-- ** setRequestMode #method:setRequestMode#

#if defined(ENABLE_OVERLOADING)
    ActorSetRequestModeMethodInfo           ,
#endif
    actorSetRequestMode                     ,


-- ** setRotation #method:setRotation#

#if defined(ENABLE_OVERLOADING)
    ActorSetRotationMethodInfo              ,
#endif
    actorSetRotation                        ,


-- ** setRotationAngle #method:setRotationAngle#

#if defined(ENABLE_OVERLOADING)
    ActorSetRotationAngleMethodInfo         ,
#endif
    actorSetRotationAngle                   ,


-- ** setScale #method:setScale#

#if defined(ENABLE_OVERLOADING)
    ActorSetScaleMethodInfo                 ,
#endif
    actorSetScale                           ,


-- ** setScaleFull #method:setScaleFull#

#if defined(ENABLE_OVERLOADING)
    ActorSetScaleFullMethodInfo             ,
#endif
    actorSetScaleFull                       ,


-- ** setScaleWithGravity #method:setScaleWithGravity#

#if defined(ENABLE_OVERLOADING)
    ActorSetScaleWithGravityMethodInfo      ,
#endif
    actorSetScaleWithGravity                ,


-- ** setScaleZ #method:setScaleZ#

#if defined(ENABLE_OVERLOADING)
    ActorSetScaleZMethodInfo                ,
#endif
    actorSetScaleZ                          ,


-- ** setShader #method:setShader#

#if defined(ENABLE_OVERLOADING)
    ActorSetShaderMethodInfo                ,
#endif
    actorSetShader                          ,


-- ** setShaderParam #method:setShaderParam#

#if defined(ENABLE_OVERLOADING)
    ActorSetShaderParamMethodInfo           ,
#endif
    actorSetShaderParam                     ,


-- ** setShaderParamFloat #method:setShaderParamFloat#

#if defined(ENABLE_OVERLOADING)
    ActorSetShaderParamFloatMethodInfo      ,
#endif
    actorSetShaderParamFloat                ,


-- ** setShaderParamInt #method:setShaderParamInt#

#if defined(ENABLE_OVERLOADING)
    ActorSetShaderParamIntMethodInfo        ,
#endif
    actorSetShaderParamInt                  ,


-- ** setSize #method:setSize#

#if defined(ENABLE_OVERLOADING)
    ActorSetSizeMethodInfo                  ,
#endif
    actorSetSize                            ,


-- ** setTextDirection #method:setTextDirection#

#if defined(ENABLE_OVERLOADING)
    ActorSetTextDirectionMethodInfo         ,
#endif
    actorSetTextDirection                   ,


-- ** setTransform #method:setTransform#

#if defined(ENABLE_OVERLOADING)
    ActorSetTransformMethodInfo             ,
#endif
    actorSetTransform                       ,


-- ** setTranslation #method:setTranslation#

#if defined(ENABLE_OVERLOADING)
    ActorSetTranslationMethodInfo           ,
#endif
    actorSetTranslation                     ,


-- ** setWidth #method:setWidth#

#if defined(ENABLE_OVERLOADING)
    ActorSetWidthMethodInfo                 ,
#endif
    actorSetWidth                           ,


-- ** setX #method:setX#

#if defined(ENABLE_OVERLOADING)
    ActorSetXMethodInfo                     ,
#endif
    actorSetX                               ,


-- ** setXAlign #method:setXAlign#

#if defined(ENABLE_OVERLOADING)
    ActorSetXAlignMethodInfo                ,
#endif
    actorSetXAlign                          ,


-- ** setXExpand #method:setXExpand#

#if defined(ENABLE_OVERLOADING)
    ActorSetXExpandMethodInfo               ,
#endif
    actorSetXExpand                         ,


-- ** setY #method:setY#

#if defined(ENABLE_OVERLOADING)
    ActorSetYMethodInfo                     ,
#endif
    actorSetY                               ,


-- ** setYAlign #method:setYAlign#

#if defined(ENABLE_OVERLOADING)
    ActorSetYAlignMethodInfo                ,
#endif
    actorSetYAlign                          ,


-- ** setYExpand #method:setYExpand#

#if defined(ENABLE_OVERLOADING)
    ActorSetYExpandMethodInfo               ,
#endif
    actorSetYExpand                         ,


-- ** setZPosition #method:setZPosition#

#if defined(ENABLE_OVERLOADING)
    ActorSetZPositionMethodInfo             ,
#endif
    actorSetZPosition                       ,


-- ** setZRotationFromGravity #method:setZRotationFromGravity#

#if defined(ENABLE_OVERLOADING)
    ActorSetZRotationFromGravityMethodInfo  ,
#endif
    actorSetZRotationFromGravity            ,


-- ** shouldPickPaint #method:shouldPickPaint#

#if defined(ENABLE_OVERLOADING)
    ActorShouldPickPaintMethodInfo          ,
#endif
    actorShouldPickPaint                    ,


-- ** show #method:show#

#if defined(ENABLE_OVERLOADING)
    ActorShowMethodInfo                     ,
#endif
    actorShow                               ,


-- ** showAll #method:showAll#

#if defined(ENABLE_OVERLOADING)
    ActorShowAllMethodInfo                  ,
#endif
    actorShowAll                            ,


-- ** transformStagePoint #method:transformStagePoint#

#if defined(ENABLE_OVERLOADING)
    ActorTransformStagePointMethodInfo      ,
#endif
    actorTransformStagePoint                ,


-- ** unmap #method:unmap#

#if defined(ENABLE_OVERLOADING)
    ActorUnmapMethodInfo                    ,
#endif
    actorUnmap                              ,


-- ** unparent #method:unparent#

#if defined(ENABLE_OVERLOADING)
    ActorUnparentMethodInfo                 ,
#endif
    actorUnparent                           ,


-- ** unrealize #method:unrealize#

#if defined(ENABLE_OVERLOADING)
    ActorUnrealizeMethodInfo                ,
#endif
    actorUnrealize                          ,


-- ** unsetFlags #method:unsetFlags#

#if defined(ENABLE_OVERLOADING)
    ActorUnsetFlagsMethodInfo               ,
#endif
    actorUnsetFlags                         ,




 -- * Properties


-- ** actions #attr:actions#
-- | Adds a t'GI.Clutter.Objects.Action.Action' to the actor
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ActorActionsPropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorActions                            ,
#endif
    clearActorActions                       ,
    constructActorActions                   ,
    setActorActions                         ,


-- ** allocation #attr: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/

#if defined(ENABLE_OVERLOADING)
    ActorAllocationPropertyInfo             ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorAllocation                         ,
#endif
    getActorAllocation                      ,


-- ** anchorGravity #attr:anchorGravity#
-- | The anchor point expressed as a t'GI.Clutter.Enums.Gravity'
-- 
-- It is highly recommended not to use [Actor:anchorX]("GI.Clutter.Objects.Actor#g:attr:anchorX"),
-- [Actor:anchorY]("GI.Clutter.Objects.Actor#g:attr:anchorY"), and [Actor:anchorGravity]("GI.Clutter.Objects.Actor#g:attr:anchorGravity") 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:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint") property instead,
-- as it will affect only the transformations.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorAnchorGravityPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorAnchorGravity                      ,
#endif
    constructActorAnchorGravity             ,
    getActorAnchorGravity                   ,
    setActorAnchorGravity                   ,


-- ** anchorX #attr: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:anchorX]("GI.Clutter.Objects.Actor#g:attr:anchorX"),
-- [Actor:anchorY]("GI.Clutter.Objects.Actor#g:attr:anchorY"), and [Actor:anchorGravity]("GI.Clutter.Objects.Actor#g:attr:anchorGravity") 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:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint") property instead,
-- as it will affect only the transformations.
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorAnchorXPropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorAnchorX                            ,
#endif
    constructActorAnchorX                   ,
    getActorAnchorX                         ,
    setActorAnchorX                         ,


-- ** anchorY #attr: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:anchorX]("GI.Clutter.Objects.Actor#g:attr:anchorX"),
-- [Actor:anchorY]("GI.Clutter.Objects.Actor#g:attr:anchorY"), and [Actor:anchorGravity]("GI.Clutter.Objects.Actor#g:attr:anchorGravity") 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:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint") property instead,
-- as it will affect only the transformations.
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorAnchorYPropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorAnchorY                            ,
#endif
    constructActorAnchorY                   ,
    getActorAnchorY                         ,
    setActorAnchorY                         ,


-- ** backgroundColor #attr:backgroundColor#
-- | Paints a solid fill of the actor\'s allocation using the specified
-- color.
-- 
-- The [Actor:backgroundColor]("GI.Clutter.Objects.Actor#g:attr:backgroundColor") property is animatable.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorBackgroundColorPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorBackgroundColor                    ,
#endif
    clearActorBackgroundColor               ,
    constructActorBackgroundColor           ,
    getActorBackgroundColor                 ,
    setActorBackgroundColor                 ,


-- ** backgroundColorSet #attr:backgroundColorSet#
-- | Whether the [Actor:backgroundColor]("GI.Clutter.Objects.Actor#g:attr:backgroundColor") property has been set.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorBackgroundColorSetPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorBackgroundColorSet                 ,
#endif
    getActorBackgroundColorSet              ,


-- ** childTransform #attr:childTransform#
-- | Applies a transformation matrix on each child of an actor.
-- 
-- Setting this property with a t'GI.Clutter.Structs.Matrix.Matrix' will set the
-- [Actor:childTransformSet]("GI.Clutter.Objects.Actor#g:attr:childTransformSet") property to 'P.True' as a side effect;
-- setting this property with 'P.Nothing' will set the
-- [Actor:childTransformSet]("GI.Clutter.Objects.Actor#g:attr:childTransformSet") property to 'P.False'.
-- 
-- The [Actor:childTransform]("GI.Clutter.Objects.Actor#g:attr:childTransform") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorChildTransformPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorChildTransform                     ,
#endif
    clearActorChildTransform                ,
    constructActorChildTransform            ,
    getActorChildTransform                  ,
    setActorChildTransform                  ,


-- ** childTransformSet #attr:childTransformSet#
-- | Whether the [Actor:childTransform]("GI.Clutter.Objects.Actor#g:attr:childTransform") property is set.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorChildTransformSetPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorChildTransformSet                  ,
#endif
    getActorChildTransformSet               ,


-- ** clip #attr:clip#
-- | The visible region of the actor, in actor-relative coordinates

#if defined(ENABLE_OVERLOADING)
    ActorClipPropertyInfo                   ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorClip                               ,
#endif
    clearActorClip                          ,
    constructActorClip                      ,
    getActorClip                            ,
    setActorClip                            ,


-- ** clipRect #attr:clipRect#
-- | The visible region of the actor, in actor-relative coordinates,
-- expressed as a t'GI.Clutter.Structs.Rect.Rect'.
-- 
-- Setting this property to 'P.Nothing' will unset the existing clip.
-- 
-- Setting this property will change the [Actor:hasClip]("GI.Clutter.Objects.Actor#g:attr:hasClip")
-- property as a side effect.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorClipRectPropertyInfo               ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorClipRect                           ,
#endif
    clearActorClipRect                      ,
    constructActorClipRect                  ,
    getActorClipRect                        ,
    setActorClipRect                        ,


-- ** clipToAllocation #attr: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 'GI.Clutter.Objects.Actor.actorSetClip'.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorClipToAllocationPropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorClipToAllocation                   ,
#endif
    constructActorClipToAllocation          ,
    getActorClipToAllocation                ,
    setActorClipToAllocation                ,


-- ** constraints #attr:constraints#
-- | Adds a t'GI.Clutter.Objects.Constraint.Constraint' to the actor
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ActorConstraintsPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorConstraints                        ,
#endif
    clearActorConstraints                   ,
    constructActorConstraints               ,
    setActorConstraints                     ,


-- ** content #attr:content#
-- | The t'GI.Clutter.Interfaces.Content.Content' implementation that controls the content
-- of the actor.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorContentPropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorContent                            ,
#endif
    clearActorContent                       ,
    constructActorContent                   ,
    getActorContent                         ,
    setActorContent                         ,


-- ** contentBox #attr:contentBox#
-- | The bounding box for the t'GI.Clutter.Interfaces.Content.Content' used by the actor.
-- 
-- The value of this property is controlled by the [Actor:allocation]("GI.Clutter.Objects.Actor#g:attr:allocation")
-- and [Actor:contentGravity]("GI.Clutter.Objects.Actor#g:attr:contentGravity") properties of t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- The bounding box for the content is guaranteed to never exceed the
-- allocation\'s of the actor.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorContentBoxPropertyInfo             ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorContentBox                         ,
#endif
    getActorContentBox                      ,


-- ** contentGravity #attr:contentGravity#
-- | The alignment that should be honoured by the t'GI.Clutter.Interfaces.Content.Content'
-- set with the [Actor:content]("GI.Clutter.Objects.Actor#g:attr:content") property.
-- 
-- Changing the value of this property will change the bounding box of
-- the content; you can use the [Actor:contentBox]("GI.Clutter.Objects.Actor#g:attr:contentBox") property to
-- get the position and size of the content within the actor\'s
-- allocation.
-- 
-- This property is meaningful only for t'GI.Clutter.Interfaces.Content.Content' implementations
-- that have a preferred size, and if the preferred size is smaller than
-- the actor\'s allocation.
-- 
-- The [Actor:contentGravity]("GI.Clutter.Objects.Actor#g:attr:contentGravity") property is animatable.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorContentGravityPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorContentGravity                     ,
#endif
    constructActorContentGravity            ,
    getActorContentGravity                  ,
    setActorContentGravity                  ,


-- ** contentRepeat #attr:contentRepeat#
-- | The repeat policy for the actor\'s [Actor:content]("GI.Clutter.Objects.Actor#g:attr:content").
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorContentRepeatPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorContentRepeat                      ,
#endif
    constructActorContentRepeat             ,
    getActorContentRepeat                   ,
    setActorContentRepeat                   ,


-- ** depth #attr:depth#
-- | The position of the actor on the Z axis.
-- 
-- The [Actor:depth]("GI.Clutter.Objects.Actor#g:attr:depth") property is relative to the parent\'s
-- modelview matrix.
-- 
-- Setting this property will call t'GI.Clutter.Structs.ContainerIface.ContainerIface'.@/sort_depth_order/@()
-- which is usually a no-op, and it\'s most likely not what you want.
-- 
-- The [Actor:depth]("GI.Clutter.Objects.Actor#g:attr:depth") property is animatable.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorDepthPropertyInfo                  ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorDepth                              ,
#endif
    constructActorDepth                     ,
    getActorDepth                           ,
    setActorDepth                           ,


-- ** effect #attr:effect#
-- | Adds t'GI.Clutter.Objects.Effect.Effect' to the list of effects be applied on a t'GI.Clutter.Objects.Actor.Actor'
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ActorEffectPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorEffect                             ,
#endif
    clearActorEffect                        ,
    constructActorEffect                    ,
    setActorEffect                          ,


-- ** firstChild #attr:firstChild#
-- | The actor\'s first child.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorFirstChildPropertyInfo             ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorFirstChild                         ,
#endif
    getActorFirstChild                      ,


-- ** fixedPositionSet #attr:fixedPositionSet#
-- | This flag controls whether the [Actor:fixedX]("GI.Clutter.Objects.Actor#g:attr:fixedX") and
-- [Actor:fixedY]("GI.Clutter.Objects.Actor#g:attr:fixedY") properties are used
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorFixedPositionSetPropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorFixedPositionSet                   ,
#endif
    constructActorFixedPositionSet          ,
    getActorFixedPositionSet                ,
    setActorFixedPositionSet                ,


-- ** fixedX #attr:fixedX#
-- | The fixed X position of the actor in pixels.
-- 
-- Writing this property sets [Actor:fixedPositionSet]("GI.Clutter.Objects.Actor#g:attr:fixedPositionSet")
-- property as well, as a side effect
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorFixedXPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorFixedX                             ,
#endif
    constructActorFixedX                    ,
    getActorFixedX                          ,
    setActorFixedX                          ,


-- ** fixedY #attr:fixedY#
-- | The fixed Y position of the actor in pixels.
-- 
-- Writing this property sets the [Actor:fixedPositionSet]("GI.Clutter.Objects.Actor#g:attr:fixedPositionSet")
-- property as well, as a side effect
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorFixedYPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorFixedY                             ,
#endif
    constructActorFixedY                    ,
    getActorFixedY                          ,
    setActorFixedY                          ,


-- ** hasClip #attr:hasClip#
-- | Whether the actor has the [Actor:clip]("GI.Clutter.Objects.Actor#g:attr:clip") property set or not

#if defined(ENABLE_OVERLOADING)
    ActorHasClipPropertyInfo                ,
#endif
    getActorHasClip                         ,


-- ** hasPointer #attr:hasPointer#
-- | Whether the actor contains the pointer of a t'GI.Clutter.Objects.InputDevice.InputDevice'
-- or not.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    ActorHasPointerPropertyInfo             ,
#endif
    getActorHasPointer                      ,


-- ** height #attr: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]("GI.Clutter.Objects.Actor#g:attr:height") property is animatable.

#if defined(ENABLE_OVERLOADING)
    ActorHeightPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorHeight                             ,
#endif
    constructActorHeight                    ,
    getActorHeight                          ,
    setActorHeight                          ,


-- ** lastChild #attr:lastChild#
-- | The actor\'s last child.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorLastChildPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorLastChild                          ,
#endif
    getActorLastChild                       ,


-- ** layoutManager #attr:layoutManager#
-- | A delegate object for controlling the layout of the children of
-- an actor.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorLayoutManagerPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorLayoutManager                      ,
#endif
    clearActorLayoutManager                 ,
    constructActorLayoutManager             ,
    getActorLayoutManager                   ,
    setActorLayoutManager                   ,


-- ** magnificationFilter #attr:magnificationFilter#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ActorMagnificationFilterPropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMagnificationFilter                ,
#endif
    constructActorMagnificationFilter       ,
    getActorMagnificationFilter             ,
    setActorMagnificationFilter             ,


-- ** mapped #attr:mapped#
-- | Whether the actor is mapped (will be painted when the stage
-- to which it belongs is mapped)
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorMappedPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMapped                             ,
#endif
    getActorMapped                          ,


-- ** marginBottom #attr: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:marginBottom]("GI.Clutter.Objects.Actor#g:attr:marginBottom") property is animatable.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorMarginBottomPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMarginBottom                       ,
#endif
    constructActorMarginBottom              ,
    getActorMarginBottom                    ,
    setActorMarginBottom                    ,


-- ** marginLeft #attr: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:marginLeft]("GI.Clutter.Objects.Actor#g:attr:marginLeft") property is animatable.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorMarginLeftPropertyInfo             ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMarginLeft                         ,
#endif
    constructActorMarginLeft                ,
    getActorMarginLeft                      ,
    setActorMarginLeft                      ,


-- ** marginRight #attr: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:marginRight]("GI.Clutter.Objects.Actor#g:attr:marginRight") property is animatable.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorMarginRightPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMarginRight                        ,
#endif
    constructActorMarginRight               ,
    getActorMarginRight                     ,
    setActorMarginRight                     ,


-- ** marginTop #attr: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:marginTop]("GI.Clutter.Objects.Actor#g:attr:marginTop") property is animatable.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorMarginTopPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMarginTop                          ,
#endif
    constructActorMarginTop                 ,
    getActorMarginTop                       ,
    setActorMarginTop                       ,


-- ** minHeight #attr:minHeight#
-- | A forced minimum height request for the actor, in pixels
-- 
-- Writing this property sets the [Actor:minHeightSet]("GI.Clutter.Objects.Actor#g:attr:minHeightSet") property
-- as well, as a side effect. This property overrides the usual height
-- request of the actor.
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorMinHeightPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMinHeight                          ,
#endif
    constructActorMinHeight                 ,
    getActorMinHeight                       ,
    setActorMinHeight                       ,


-- ** minHeightSet #attr:minHeightSet#
-- | This flag controls whether the [Actor:minHeight]("GI.Clutter.Objects.Actor#g:attr:minHeight") property
-- is used
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorMinHeightSetPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMinHeightSet                       ,
#endif
    constructActorMinHeightSet              ,
    getActorMinHeightSet                    ,
    setActorMinHeightSet                    ,


-- ** minWidth #attr:minWidth#
-- | A forced minimum width request for the actor, in pixels
-- 
-- Writing this property sets the [Actor:minWidthSet]("GI.Clutter.Objects.Actor#g:attr:minWidthSet") property
-- as well, as a side effect.
-- 
-- This property overrides the usual width request of the actor.
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorMinWidthPropertyInfo               ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMinWidth                           ,
#endif
    constructActorMinWidth                  ,
    getActorMinWidth                        ,
    setActorMinWidth                        ,


-- ** minWidthSet #attr:minWidthSet#
-- | This flag controls whether the [Actor:minWidth]("GI.Clutter.Objects.Actor#g:attr:minWidth") property
-- is used
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorMinWidthSetPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMinWidthSet                        ,
#endif
    constructActorMinWidthSet               ,
    getActorMinWidthSet                     ,
    setActorMinWidthSet                     ,


-- ** minificationFilter #attr:minificationFilter#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ActorMinificationFilterPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorMinificationFilter                 ,
#endif
    constructActorMinificationFilter        ,
    getActorMinificationFilter              ,
    setActorMinificationFilter              ,


-- ** name #attr:name#
-- | The name of the actor
-- 
-- /Since: 0.2/

#if defined(ENABLE_OVERLOADING)
    ActorNamePropertyInfo                   ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorName                               ,
#endif
    constructActorName                      ,
    getActorName                            ,
    setActorName                            ,


-- ** naturalHeight #attr:naturalHeight#
-- | A forced natural height request for the actor, in pixels
-- 
-- Writing this property sets the [Actor:naturalHeightSet]("GI.Clutter.Objects.Actor#g:attr:naturalHeightSet")
-- property as well, as a side effect. This property overrides the
-- usual height request of the actor
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorNaturalHeightPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorNaturalHeight                      ,
#endif
    constructActorNaturalHeight             ,
    getActorNaturalHeight                   ,
    setActorNaturalHeight                   ,


-- ** naturalHeightSet #attr:naturalHeightSet#
-- | This flag controls whether the [Actor:naturalHeight]("GI.Clutter.Objects.Actor#g:attr:naturalHeight") property
-- is used
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorNaturalHeightSetPropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorNaturalHeightSet                   ,
#endif
    constructActorNaturalHeightSet          ,
    getActorNaturalHeightSet                ,
    setActorNaturalHeightSet                ,


-- ** naturalWidth #attr:naturalWidth#
-- | A forced natural width request for the actor, in pixels
-- 
-- Writing this property sets the [Actor:naturalWidthSet]("GI.Clutter.Objects.Actor#g:attr:naturalWidthSet")
-- property as well, as a side effect. This property overrides the
-- usual width request of the actor
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorNaturalWidthPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorNaturalWidth                       ,
#endif
    constructActorNaturalWidth              ,
    getActorNaturalWidth                    ,
    setActorNaturalWidth                    ,


-- ** naturalWidthSet #attr:naturalWidthSet#
-- | This flag controls whether the [Actor:naturalWidth]("GI.Clutter.Objects.Actor#g:attr:naturalWidth") property
-- is used
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorNaturalWidthSetPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorNaturalWidthSet                    ,
#endif
    constructActorNaturalWidthSet           ,
    getActorNaturalWidthSet                 ,
    setActorNaturalWidthSet                 ,


-- ** offscreenRedirect #attr: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
-- 'GI.Clutter.Objects.Actor.actorSetOffscreenRedirect' for details.
-- 
-- /Since: 1.8/

#if defined(ENABLE_OVERLOADING)
    ActorOffscreenRedirectPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorOffscreenRedirect                  ,
#endif
    constructActorOffscreenRedirect         ,
    getActorOffscreenRedirect               ,
    setActorOffscreenRedirect               ,


-- ** opacity #attr:opacity#
-- | Opacity of an actor, between 0 (fully transparent) and
-- 255 (fully opaque)
-- 
-- The [Actor:opacity]("GI.Clutter.Objects.Actor#g:attr:opacity") property is animatable.

#if defined(ENABLE_OVERLOADING)
    ActorOpacityPropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorOpacity                            ,
#endif
    constructActorOpacity                   ,
    getActorOpacity                         ,
    setActorOpacity                         ,


-- ** pivotPoint #attr: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:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorPivotPointPropertyInfo             ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorPivotPoint                         ,
#endif
    clearActorPivotPoint                    ,
    constructActorPivotPoint                ,
    getActorPivotPoint                      ,
    setActorPivotPoint                      ,


-- ** pivotPointZ #attr:pivotPointZ#
-- | The Z component of the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint"), expressed as a value
-- along the Z axis.
-- 
-- The [Actor:pivotPointZ]("GI.Clutter.Objects.Actor#g:attr:pivotPointZ") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorPivotPointZPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorPivotPointZ                        ,
#endif
    constructActorPivotPointZ               ,
    getActorPivotPointZ                     ,
    setActorPivotPointZ                     ,


-- ** position #attr:position#
-- | The position of the origin of the actor.
-- 
-- This property is a shorthand for setting and getting the
-- [Actor:x]("GI.Clutter.Objects.Actor#g:attr:x") and [Actor:y]("GI.Clutter.Objects.Actor#g:attr:y") properties at the same
-- time.
-- 
-- The [Actor:position]("GI.Clutter.Objects.Actor#g:attr:position") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorPositionPropertyInfo               ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorPosition                           ,
#endif
    clearActorPosition                      ,
    constructActorPosition                  ,
    getActorPosition                        ,
    setActorPosition                        ,


-- ** reactive #attr:reactive#
-- | Whether the actor is reactive to events or not
-- 
-- Only reactive actors will emit event-related signals
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorReactivePropertyInfo               ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorReactive                           ,
#endif
    constructActorReactive                  ,
    getActorReactive                        ,
    setActorReactive                        ,


-- ** realized #attr:realized#
-- | Whether the actor has been realized
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorRealizedPropertyInfo               ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRealized                           ,
#endif
    getActorRealized                        ,


-- ** requestMode #attr:requestMode#
-- | Request mode for the t'GI.Clutter.Objects.Actor.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 t'GI.Clutter.Objects.Actor.Actor' \"child\".
-- 
-- The 'GI.Clutter.Objects.Actor.actorGetPreferredSize' function will implement this
-- check for you.
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorRequestModePropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRequestMode                        ,
#endif
    constructActorRequestMode               ,
    getActorRequestMode                     ,
    setActorRequestMode                     ,


-- ** rotationAngleX #attr:rotationAngleX#
-- | The rotation angle on the X axis.
-- 
-- The [Actor:rotationAngleX]("GI.Clutter.Objects.Actor#g:attr:rotationAngleX") property is animatable.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorRotationAngleXPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRotationAngleX                     ,
#endif
    constructActorRotationAngleX            ,
    getActorRotationAngleX                  ,
    setActorRotationAngleX                  ,


-- ** rotationAngleY #attr:rotationAngleY#
-- | The rotation angle on the Y axis
-- 
-- The [Actor:rotationAngleY]("GI.Clutter.Objects.Actor#g:attr:rotationAngleY") property is animatable.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorRotationAngleYPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRotationAngleY                     ,
#endif
    constructActorRotationAngleY            ,
    getActorRotationAngleY                  ,
    setActorRotationAngleY                  ,


-- ** rotationAngleZ #attr:rotationAngleZ#
-- | The rotation angle on the Z axis
-- 
-- The [Actor:rotationAngleZ]("GI.Clutter.Objects.Actor#g:attr:rotationAngleZ") property is animatable.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorRotationAngleZPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRotationAngleZ                     ,
#endif
    constructActorRotationAngleZ            ,
    getActorRotationAngleZ                  ,
    setActorRotationAngleZ                  ,


-- ** rotationCenterX #attr:rotationCenterX#
-- | The rotation center on the X axis.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorRotationCenterXPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRotationCenterX                    ,
#endif
    clearActorRotationCenterX               ,
    constructActorRotationCenterX           ,
    getActorRotationCenterX                 ,
    setActorRotationCenterX                 ,


-- ** rotationCenterY #attr:rotationCenterY#
-- | The rotation center on the Y axis.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorRotationCenterYPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRotationCenterY                    ,
#endif
    clearActorRotationCenterY               ,
    constructActorRotationCenterY           ,
    getActorRotationCenterY                 ,
    setActorRotationCenterY                 ,


-- ** rotationCenterZ #attr:rotationCenterZ#
-- | The rotation center on the Z axis.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorRotationCenterZPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRotationCenterZ                    ,
#endif
    clearActorRotationCenterZ               ,
    constructActorRotationCenterZ           ,
    getActorRotationCenterZ                 ,
    setActorRotationCenterZ                 ,


-- ** rotationCenterZGravity #attr:rotationCenterZGravity#
-- | The rotation center on the Z axis expressed as a t'GI.Clutter.Enums.Gravity'.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorRotationCenterZGravityPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorRotationCenterZGravity             ,
#endif
    constructActorRotationCenterZGravity    ,
    getActorRotationCenterZGravity          ,
    setActorRotationCenterZGravity          ,


-- ** scaleCenterX #attr:scaleCenterX#
-- | The horizontal center point for scaling
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorScaleCenterXPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorScaleCenterX                       ,
#endif
    constructActorScaleCenterX              ,
    getActorScaleCenterX                    ,
    setActorScaleCenterX                    ,


-- ** scaleCenterY #attr:scaleCenterY#
-- | The vertical center point for scaling
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorScaleCenterYPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorScaleCenterY                       ,
#endif
    constructActorScaleCenterY              ,
    getActorScaleCenterY                    ,
    setActorScaleCenterY                    ,


-- ** scaleGravity #attr:scaleGravity#
-- | The center point for scaling expressed as a t'GI.Clutter.Enums.Gravity'
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorScaleGravityPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorScaleGravity                       ,
#endif
    constructActorScaleGravity              ,
    getActorScaleGravity                    ,
    setActorScaleGravity                    ,


-- ** scaleX #attr:scaleX#
-- | The horizontal scale of the actor.
-- 
-- The [Actor:scaleX]("GI.Clutter.Objects.Actor#g:attr:scaleX") property is animatable.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorScaleXPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorScaleX                             ,
#endif
    constructActorScaleX                    ,
    getActorScaleX                          ,
    setActorScaleX                          ,


-- ** scaleY #attr:scaleY#
-- | The vertical scale of the actor.
-- 
-- The [Actor:scaleY]("GI.Clutter.Objects.Actor#g:attr:scaleY") property is animatable.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    ActorScaleYPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorScaleY                             ,
#endif
    constructActorScaleY                    ,
    getActorScaleY                          ,
    setActorScaleY                          ,


-- ** scaleZ #attr:scaleZ#
-- | The scale factor of the actor along the Z axis.
-- 
-- The [Actor:scaleY]("GI.Clutter.Objects.Actor#g:attr:scaleY") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorScaleZPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorScaleZ                             ,
#endif
    constructActorScaleZ                    ,
    getActorScaleZ                          ,
    setActorScaleZ                          ,


-- ** showOnSetParent #attr:showOnSetParent#
-- | If 'P.True', the actor is automatically shown when parented.
-- 
-- Calling 'GI.Clutter.Objects.Actor.actorHide' on an actor which has not been
-- parented will set this property to 'P.False' as a side effect.
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    ActorShowOnSetParentPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorShowOnSetParent                    ,
#endif
    constructActorShowOnSetParent           ,
    getActorShowOnSetParent                 ,
    setActorShowOnSetParent                 ,


-- ** size #attr:size#
-- | The size of the actor.
-- 
-- This property is a shorthand for setting and getting the
-- [Actor:width]("GI.Clutter.Objects.Actor#g:attr:width") and [Actor:height]("GI.Clutter.Objects.Actor#g:attr:height") at the same time.
-- 
-- The [Actor:size]("GI.Clutter.Objects.Actor#g:attr:size") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorSizePropertyInfo                   ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorSize                               ,
#endif
    clearActorSize                          ,
    constructActorSize                      ,
    getActorSize                            ,
    setActorSize                            ,


-- ** textDirection #attr:textDirection#
-- | The direction of the text inside a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActorTextDirectionPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorTextDirection                      ,
#endif
    constructActorTextDirection             ,
    getActorTextDirection                   ,
    setActorTextDirection                   ,


-- ** transform #attr:transform#
-- | Overrides the transformations of a t'GI.Clutter.Objects.Actor.Actor' with a custom
-- matrix.
-- 
-- The matrix specified by the [Actor:transform]("GI.Clutter.Objects.Actor#g:attr:transform") property is
-- applied to the actor and its children relative to the actor\'s
-- [Actor:allocation]("GI.Clutter.Objects.Actor#g:attr:allocation") and [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- Application code should rarely need to use this function directly.
-- 
-- Setting this property with a t'GI.Clutter.Structs.Matrix.Matrix' will set the
-- [Actor:transformSet]("GI.Clutter.Objects.Actor#g:attr:transformSet") property to 'P.True' as a side effect;
-- setting this property with 'P.Nothing' will set the
-- [Actor:transformSet]("GI.Clutter.Objects.Actor#g:attr:transformSet") property to 'P.False'.
-- 
-- The [Actor:transform]("GI.Clutter.Objects.Actor#g:attr:transform") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorTransformPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorTransform                          ,
#endif
    clearActorTransform                     ,
    constructActorTransform                 ,
    getActorTransform                       ,
    setActorTransform                       ,


-- ** transformSet #attr:transformSet#
-- | Whether the [Actor:transform]("GI.Clutter.Objects.Actor#g:attr:transform") property is set.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorTransformSetPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorTransformSet                       ,
#endif
    getActorTransformSet                    ,


-- ** translationX #attr:translationX#
-- | An additional translation applied along the X axis, relative
-- to the actor\'s [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- The [Actor:translationX]("GI.Clutter.Objects.Actor#g:attr:translationX") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorTranslationXPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorTranslationX                       ,
#endif
    constructActorTranslationX              ,
    getActorTranslationX                    ,
    setActorTranslationX                    ,


-- ** translationY #attr:translationY#
-- | An additional translation applied along the Y axis, relative
-- to the actor\'s [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- The [Actor:translationY]("GI.Clutter.Objects.Actor#g:attr:translationY") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorTranslationYPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorTranslationY                       ,
#endif
    constructActorTranslationY              ,
    getActorTranslationY                    ,
    setActorTranslationY                    ,


-- ** translationZ #attr:translationZ#
-- | An additional translation applied along the Z axis, relative
-- to the actor\'s [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- The [Actor:translationZ]("GI.Clutter.Objects.Actor#g:attr:translationZ") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorTranslationZPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorTranslationZ                       ,
#endif
    constructActorTranslationZ              ,
    getActorTranslationZ                    ,
    setActorTranslationZ                    ,


-- ** visible #attr:visible#
-- | Whether the actor is set to be visible or not
-- 
-- See also [Actor:mapped]("GI.Clutter.Objects.Actor#g:attr:mapped")

#if defined(ENABLE_OVERLOADING)
    ActorVisiblePropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorVisible                            ,
#endif
    constructActorVisible                   ,
    getActorVisible                         ,
    setActorVisible                         ,


-- ** width #attr: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]("GI.Clutter.Objects.Actor#g:attr:width") property is animatable.

#if defined(ENABLE_OVERLOADING)
    ActorWidthPropertyInfo                  ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorWidth                              ,
#endif
    constructActorWidth                     ,
    getActorWidth                           ,
    setActorWidth                           ,


-- ** x #attr: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]("GI.Clutter.Objects.Actor#g:attr:x") property is animatable.

#if defined(ENABLE_OVERLOADING)
    ActorXPropertyInfo                      ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorX                                  ,
#endif
    constructActorX                         ,
    getActorX                               ,
    setActorX                               ,


-- ** xAlign #attr: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:xExpand]("GI.Clutter.Objects.Actor#g:attr:xExpand")
-- property.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorXAlignPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorXAlign                             ,
#endif
    constructActorXAlign                    ,
    getActorXAlign                          ,
    setActorXAlign                          ,


-- ** xExpand #attr:xExpand#
-- | Whether a layout manager should assign more space to the actor on
-- the X axis.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorXExpandPropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorXExpand                            ,
#endif
    constructActorXExpand                   ,
    getActorXExpand                         ,
    setActorXExpand                         ,


-- ** y #attr: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]("GI.Clutter.Objects.Actor#g:attr:y") property is animatable.

#if defined(ENABLE_OVERLOADING)
    ActorYPropertyInfo                      ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorY                                  ,
#endif
    constructActorY                         ,
    getActorY                               ,
    setActorY                               ,


-- ** yAlign #attr:yAlign#
-- | The alignment of an actor on the Y axis, if the actor has been given
-- extra space for its allocation.
-- 
-- /Since: 1.10/

#if defined(ENABLE_OVERLOADING)
    ActorYAlignPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorYAlign                             ,
#endif
    constructActorYAlign                    ,
    getActorYAlign                          ,
    setActorYAlign                          ,


-- ** yExpand #attr:yExpand#
-- | Whether a layout manager should assign more space to the actor on
-- the Y axis.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorYExpandPropertyInfo                ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorYExpand                            ,
#endif
    constructActorYExpand                   ,
    getActorYExpand                         ,
    setActorYExpand                         ,


-- ** zPosition #attr: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:zPosition]("GI.Clutter.Objects.Actor#g:attr:zPosition") does not affect the paint or allocation
-- order.
-- 
-- The [Actor:zPosition]("GI.Clutter.Objects.Actor#g:attr:zPosition") property is animatable.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    ActorZPositionPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    actorZPosition                          ,
#endif
    constructActorZPosition                 ,
    getActorZPosition                       ,
    setActorZPosition                       ,




 -- * Signals


-- ** allocationChanged #signal:allocationChanged#

    ActorAllocationChangedCallback          ,
#if defined(ENABLE_OVERLOADING)
    ActorAllocationChangedSignalInfo        ,
#endif
    afterActorAllocationChanged             ,
    onActorAllocationChanged                ,


-- ** buttonPressEvent #signal:buttonPressEvent#

    ActorButtonPressEventCallback           ,
#if defined(ENABLE_OVERLOADING)
    ActorButtonPressEventSignalInfo         ,
#endif
    afterActorButtonPressEvent              ,
    onActorButtonPressEvent                 ,


-- ** buttonReleaseEvent #signal:buttonReleaseEvent#

    ActorButtonReleaseEventCallback         ,
#if defined(ENABLE_OVERLOADING)
    ActorButtonReleaseEventSignalInfo       ,
#endif
    afterActorButtonReleaseEvent            ,
    onActorButtonReleaseEvent               ,


-- ** capturedEvent #signal:capturedEvent#

    ActorCapturedEventCallback              ,
#if defined(ENABLE_OVERLOADING)
    ActorCapturedEventSignalInfo            ,
#endif
    afterActorCapturedEvent                 ,
    onActorCapturedEvent                    ,


-- ** destroy #signal:destroy#

    ActorDestroyCallback                    ,
#if defined(ENABLE_OVERLOADING)
    ActorDestroySignalInfo                  ,
#endif
    afterActorDestroy                       ,
    onActorDestroy                          ,


-- ** enterEvent #signal:enterEvent#

    ActorEnterEventCallback                 ,
#if defined(ENABLE_OVERLOADING)
    ActorEnterEventSignalInfo               ,
#endif
    afterActorEnterEvent                    ,
    onActorEnterEvent                       ,


-- ** event #signal:event#

    ActorEventCallback                      ,
#if defined(ENABLE_OVERLOADING)
    ActorEventSignalInfo                    ,
#endif
    afterActorEvent                         ,
    onActorEvent                            ,


-- ** hide #signal:hide#

    ActorHideCallback                       ,
#if defined(ENABLE_OVERLOADING)
    ActorHideSignalInfo                     ,
#endif
    afterActorHide                          ,
    onActorHide                             ,


-- ** keyFocusIn #signal:keyFocusIn#

    ActorKeyFocusInCallback                 ,
#if defined(ENABLE_OVERLOADING)
    ActorKeyFocusInSignalInfo               ,
#endif
    afterActorKeyFocusIn                    ,
    onActorKeyFocusIn                       ,


-- ** keyFocusOut #signal:keyFocusOut#

    ActorKeyFocusOutCallback                ,
#if defined(ENABLE_OVERLOADING)
    ActorKeyFocusOutSignalInfo              ,
#endif
    afterActorKeyFocusOut                   ,
    onActorKeyFocusOut                      ,


-- ** keyPressEvent #signal:keyPressEvent#

    ActorKeyPressEventCallback              ,
#if defined(ENABLE_OVERLOADING)
    ActorKeyPressEventSignalInfo            ,
#endif
    afterActorKeyPressEvent                 ,
    onActorKeyPressEvent                    ,


-- ** keyReleaseEvent #signal:keyReleaseEvent#

    ActorKeyReleaseEventCallback            ,
#if defined(ENABLE_OVERLOADING)
    ActorKeyReleaseEventSignalInfo          ,
#endif
    afterActorKeyReleaseEvent               ,
    onActorKeyReleaseEvent                  ,


-- ** leaveEvent #signal:leaveEvent#

    ActorLeaveEventCallback                 ,
#if defined(ENABLE_OVERLOADING)
    ActorLeaveEventSignalInfo               ,
#endif
    afterActorLeaveEvent                    ,
    onActorLeaveEvent                       ,


-- ** motionEvent #signal:motionEvent#

    ActorMotionEventCallback                ,
#if defined(ENABLE_OVERLOADING)
    ActorMotionEventSignalInfo              ,
#endif
    afterActorMotionEvent                   ,
    onActorMotionEvent                      ,


-- ** paint #signal:paint#

    ActorPaintCallback                      ,
#if defined(ENABLE_OVERLOADING)
    ActorPaintSignalInfo                    ,
#endif
    afterActorPaint                         ,
    onActorPaint                            ,


-- ** parentSet #signal:parentSet#

    ActorParentSetCallback                  ,
#if defined(ENABLE_OVERLOADING)
    ActorParentSetSignalInfo                ,
#endif
    afterActorParentSet                     ,
    onActorParentSet                        ,


-- ** pick #signal:pick#

    ActorPickCallback                       ,
#if defined(ENABLE_OVERLOADING)
    ActorPickSignalInfo                     ,
#endif
    afterActorPick                          ,
    onActorPick                             ,


-- ** queueRedraw #signal:queueRedraw#

    ActorQueueRedrawCallback                ,
#if defined(ENABLE_OVERLOADING)
    ActorQueueRedrawSignalInfo              ,
#endif
    afterActorQueueRedraw                   ,
    onActorQueueRedraw                      ,


-- ** queueRelayout #signal:queueRelayout#

    ActorQueueRelayoutCallback              ,
#if defined(ENABLE_OVERLOADING)
    ActorQueueRelayoutSignalInfo            ,
#endif
    afterActorQueueRelayout                 ,
    onActorQueueRelayout                    ,


-- ** realize #signal:realize#

    ActorRealizeCallback                    ,
#if defined(ENABLE_OVERLOADING)
    ActorRealizeSignalInfo                  ,
#endif
    afterActorRealize                       ,
    onActorRealize                          ,


-- ** scrollEvent #signal:scrollEvent#

    ActorScrollEventCallback                ,
#if defined(ENABLE_OVERLOADING)
    ActorScrollEventSignalInfo              ,
#endif
    afterActorScrollEvent                   ,
    onActorScrollEvent                      ,


-- ** show #signal:show#

    ActorShowCallback                       ,
#if defined(ENABLE_OVERLOADING)
    ActorShowSignalInfo                     ,
#endif
    afterActorShow                          ,
    onActorShow                             ,


-- ** touchEvent #signal:touchEvent#

    ActorTouchEventCallback                 ,
#if defined(ENABLE_OVERLOADING)
    ActorTouchEventSignalInfo               ,
#endif
    afterActorTouchEvent                    ,
    onActorTouchEvent                       ,


-- ** transitionStopped #signal:transitionStopped#

    ActorTransitionStoppedCallback          ,
#if defined(ENABLE_OVERLOADING)
    ActorTransitionStoppedSignalInfo        ,
#endif
    afterActorTransitionStopped             ,
    onActorTransitionStopped                ,


-- ** transitionsCompleted #signal:transitionsCompleted#

    ActorTransitionsCompletedCallback       ,
#if defined(ENABLE_OVERLOADING)
    ActorTransitionsCompletedSignalInfo     ,
#endif
    afterActorTransitionsCompleted          ,
    onActorTransitionsCompleted             ,


-- ** unrealize #signal:unrealize#

    ActorUnrealizeCallback                  ,
#if defined(ENABLE_OVERLOADING)
    ActorUnrealizeSignalInfo                ,
#endif
    afterActorUnrealize                     ,
    onActorUnrealize                        ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.RectangleInt as Cairo.RectangleInt
import qualified GI.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Animatable as Clutter.Animatable
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Container as Clutter.Container
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Content as Clutter.Content
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Action as Clutter.Action
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Alpha as Clutter.Alpha
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animation as Clutter.Animation
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animator as Clutter.Animator
import {-# SOURCE #-} qualified GI.Clutter.Objects.Backend as Clutter.Backend
import {-# SOURCE #-} qualified GI.Clutter.Objects.ChildMeta as Clutter.ChildMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Constraint as Clutter.Constraint
import {-# SOURCE #-} qualified GI.Clutter.Objects.DeviceManager as Clutter.DeviceManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.Group as Clutter.Group
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Interval as Clutter.Interval
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutManager as Clutter.LayoutManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutMeta as Clutter.LayoutMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Script as Clutter.Script
import {-# SOURCE #-} qualified GI.Clutter.Objects.Shader as Clutter.Shader
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage
import {-# SOURCE #-} qualified GI.Clutter.Objects.State as Clutter.State
import {-# SOURCE #-} qualified GI.Clutter.Objects.Timeline as Clutter.Timeline
import {-# SOURCE #-} qualified GI.Clutter.Objects.Transition as Clutter.Transition
import {-# SOURCE #-} qualified GI.Clutter.Structs.ActorBox as Clutter.ActorBox
import {-# SOURCE #-} qualified GI.Clutter.Structs.AnimatorKey as Clutter.AnimatorKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.ButtonEvent as Clutter.ButtonEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import {-# SOURCE #-} qualified GI.Clutter.Structs.CrossingEvent as Clutter.CrossingEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.EventSequence as Clutter.EventSequence
import {-# SOURCE #-} qualified GI.Clutter.Structs.Fog as Clutter.Fog
import {-# SOURCE #-} qualified GI.Clutter.Structs.Geometry as Clutter.Geometry
import {-# SOURCE #-} qualified GI.Clutter.Structs.KeyEvent as Clutter.KeyEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Margin as Clutter.Margin
import {-# SOURCE #-} qualified GI.Clutter.Structs.Matrix as Clutter.Matrix
import {-# SOURCE #-} qualified GI.Clutter.Structs.MotionEvent as Clutter.MotionEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.PaintVolume as Clutter.PaintVolume
import {-# SOURCE #-} qualified GI.Clutter.Structs.Perspective as Clutter.Perspective
import {-# SOURCE #-} qualified GI.Clutter.Structs.Point as Clutter.Point
import {-# SOURCE #-} qualified GI.Clutter.Structs.Rect as Clutter.Rect
import {-# SOURCE #-} qualified GI.Clutter.Structs.ScrollEvent as Clutter.ScrollEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Size as Clutter.Size
import {-# SOURCE #-} qualified GI.Clutter.Structs.StateKey as Clutter.StateKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.Vertex as Clutter.Vertex
import {-# SOURCE #-} qualified GI.Clutter.Unions.Event as Clutter.Event
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Json.Structs.Node as Json.Node
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.Layout as Pango.Layout

#else
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.Cairo.Structs.RectangleInt as Cairo.RectangleInt
import qualified GI.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Animatable as Clutter.Animatable
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Container as Clutter.Container
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Content as Clutter.Content
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Action as Clutter.Action
import {-# SOURCE #-} qualified GI.Clutter.Objects.Alpha as Clutter.Alpha
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animation as Clutter.Animation
import {-# SOURCE #-} qualified GI.Clutter.Objects.Constraint as Clutter.Constraint
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutManager as Clutter.LayoutManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.Shader as Clutter.Shader
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage
import {-# SOURCE #-} qualified GI.Clutter.Objects.Timeline as Clutter.Timeline
import {-# SOURCE #-} qualified GI.Clutter.Objects.Transition as Clutter.Transition
import {-# SOURCE #-} qualified GI.Clutter.Structs.ActorBox as Clutter.ActorBox
import {-# SOURCE #-} qualified GI.Clutter.Structs.ButtonEvent as Clutter.ButtonEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import {-# SOURCE #-} qualified GI.Clutter.Structs.CrossingEvent as Clutter.CrossingEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Geometry as Clutter.Geometry
import {-# SOURCE #-} qualified GI.Clutter.Structs.KeyEvent as Clutter.KeyEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Margin as Clutter.Margin
import {-# SOURCE #-} qualified GI.Clutter.Structs.Matrix as Clutter.Matrix
import {-# SOURCE #-} qualified GI.Clutter.Structs.MotionEvent as Clutter.MotionEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.PaintVolume as Clutter.PaintVolume
import {-# SOURCE #-} qualified GI.Clutter.Structs.Point as Clutter.Point
import {-# SOURCE #-} qualified GI.Clutter.Structs.Rect as Clutter.Rect
import {-# SOURCE #-} qualified GI.Clutter.Structs.ScrollEvent as Clutter.ScrollEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Size as Clutter.Size
import {-# SOURCE #-} qualified GI.Clutter.Structs.Vertex as Clutter.Vertex
import {-# SOURCE #-} qualified GI.Clutter.Unions.Event as Clutter.Event
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.Layout as Pango.Layout

#endif

-- | Memory-managed wrapper type.
newtype Actor = Actor (SP.ManagedPtr Actor)
    deriving (Actor -> Actor -> Bool
(Actor -> Actor -> Bool) -> (Actor -> Actor -> Bool) -> Eq Actor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Actor -> Actor -> Bool
== :: Actor -> Actor -> Bool
$c/= :: Actor -> Actor -> Bool
/= :: Actor -> Actor -> Bool
Eq)

instance SP.ManagedPtrNewtype Actor where
    toManagedPtr :: Actor -> ManagedPtr Actor
toManagedPtr (Actor ManagedPtr Actor
p) = ManagedPtr Actor
p

foreign import ccall "clutter_actor_get_type"
    c_clutter_actor_get_type :: IO B.Types.GType

instance B.Types.TypedObject Actor where
    glibType :: IO GType
glibType = IO GType
c_clutter_actor_get_type

instance B.Types.GObject Actor

-- | Type class for types which can be safely cast to `Actor`, for instance with `toActor`.
class (SP.GObject o, O.IsDescendantOf Actor o) => IsActor o
instance (SP.GObject o, O.IsDescendantOf Actor o) => IsActor o

instance O.HasParentTypes Actor
type instance O.ParentTypes Actor = '[GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Clutter.Animatable.Animatable, Clutter.Container.Container, Clutter.Scriptable.Scriptable]

-- | Cast to `Actor`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toActor :: (MIO.MonadIO m, IsActor o) => o -> m Actor
toActor :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Actor
toActor = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Actor -> m Actor) -> (o -> IO Actor) -> o -> m Actor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Actor -> Actor) -> o -> IO Actor
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Actor -> Actor
Actor

-- | Convert 'Actor' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Actor) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_actor_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Actor -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Actor
P.Nothing = Ptr GValue -> Ptr Actor -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Actor
forall a. Ptr a
FP.nullPtr :: FP.Ptr Actor)
    gvalueSet_ Ptr GValue
gv (P.Just Actor
obj) = Actor -> (Ptr Actor -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Actor
obj (Ptr GValue -> Ptr Actor -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Actor)
gvalueGet_ Ptr GValue
gv = do
        Ptr Actor
ptr <- Ptr GValue -> IO (Ptr Actor)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Actor)
        if Ptr Actor
ptr Ptr Actor -> Ptr Actor -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Actor
forall a. Ptr a
FP.nullPtr
        then Actor -> Maybe Actor
forall a. a -> Maybe a
P.Just (Actor -> Maybe Actor) -> IO Actor -> IO (Maybe Actor)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Actor -> Actor
Actor Ptr Actor
ptr
        else Maybe Actor -> IO (Maybe Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Actor
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveActorMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveActorMethod "addAction" o = ActorAddActionMethodInfo
    ResolveActorMethod "addActionWithName" o = ActorAddActionWithNameMethodInfo
    ResolveActorMethod "addActor" o = Clutter.Container.ContainerAddActorMethodInfo
    ResolveActorMethod "addChild" o = ActorAddChildMethodInfo
    ResolveActorMethod "addConstraint" o = ActorAddConstraintMethodInfo
    ResolveActorMethod "addConstraintWithName" o = ActorAddConstraintWithNameMethodInfo
    ResolveActorMethod "addEffect" o = ActorAddEffectMethodInfo
    ResolveActorMethod "addEffectWithName" o = ActorAddEffectWithNameMethodInfo
    ResolveActorMethod "addTransition" o = ActorAddTransitionMethodInfo
    ResolveActorMethod "allocate" o = ActorAllocateMethodInfo
    ResolveActorMethod "allocateAlignFill" o = ActorAllocateAlignFillMethodInfo
    ResolveActorMethod "allocateAvailableSize" o = ActorAllocateAvailableSizeMethodInfo
    ResolveActorMethod "allocatePreferredSize" o = ActorAllocatePreferredSizeMethodInfo
    ResolveActorMethod "animateProperty" o = Clutter.Animatable.AnimatableAnimatePropertyMethodInfo
    ResolveActorMethod "animateWithAlphav" o = ActorAnimateWithAlphavMethodInfo
    ResolveActorMethod "animateWithTimelinev" o = ActorAnimateWithTimelinevMethodInfo
    ResolveActorMethod "animatev" o = ActorAnimatevMethodInfo
    ResolveActorMethod "applyRelativeTransformToPoint" o = ActorApplyRelativeTransformToPointMethodInfo
    ResolveActorMethod "applyTransformToPoint" o = ActorApplyTransformToPointMethodInfo
    ResolveActorMethod "bindModel" o = ActorBindModelMethodInfo
    ResolveActorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveActorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveActorMethod "childGetProperty" o = Clutter.Container.ContainerChildGetPropertyMethodInfo
    ResolveActorMethod "childNotify" o = Clutter.Container.ContainerChildNotifyMethodInfo
    ResolveActorMethod "childSetProperty" o = Clutter.Container.ContainerChildSetPropertyMethodInfo
    ResolveActorMethod "clearActions" o = ActorClearActionsMethodInfo
    ResolveActorMethod "clearConstraints" o = ActorClearConstraintsMethodInfo
    ResolveActorMethod "clearEffects" o = ActorClearEffectsMethodInfo
    ResolveActorMethod "contains" o = ActorContainsMethodInfo
    ResolveActorMethod "continuePaint" o = ActorContinuePaintMethodInfo
    ResolveActorMethod "createChildMeta" o = Clutter.Container.ContainerCreateChildMetaMethodInfo
    ResolveActorMethod "createPangoContext" o = ActorCreatePangoContextMethodInfo
    ResolveActorMethod "createPangoLayout" o = ActorCreatePangoLayoutMethodInfo
    ResolveActorMethod "destroy" o = ActorDestroyMethodInfo
    ResolveActorMethod "destroyAllChildren" o = ActorDestroyAllChildrenMethodInfo
    ResolveActorMethod "destroyChildMeta" o = Clutter.Container.ContainerDestroyChildMetaMethodInfo
    ResolveActorMethod "detachAnimation" o = ActorDetachAnimationMethodInfo
    ResolveActorMethod "event" o = ActorEventMethodInfo
    ResolveActorMethod "findChildByName" o = Clutter.Container.ContainerFindChildByNameMethodInfo
    ResolveActorMethod "findProperty" o = Clutter.Animatable.AnimatableFindPropertyMethodInfo
    ResolveActorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveActorMethod "foreach" o = Clutter.Container.ContainerForeachMethodInfo
    ResolveActorMethod "foreachWithInternals" o = Clutter.Container.ContainerForeachWithInternalsMethodInfo
    ResolveActorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveActorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveActorMethod "grabKeyFocus" o = ActorGrabKeyFocusMethodInfo
    ResolveActorMethod "hasActions" o = ActorHasActionsMethodInfo
    ResolveActorMethod "hasAllocation" o = ActorHasAllocationMethodInfo
    ResolveActorMethod "hasClip" o = ActorHasClipMethodInfo
    ResolveActorMethod "hasConstraints" o = ActorHasConstraintsMethodInfo
    ResolveActorMethod "hasEffects" o = ActorHasEffectsMethodInfo
    ResolveActorMethod "hasKeyFocus" o = ActorHasKeyFocusMethodInfo
    ResolveActorMethod "hasOverlaps" o = ActorHasOverlapsMethodInfo
    ResolveActorMethod "hasPointer" o = ActorHasPointerMethodInfo
    ResolveActorMethod "hide" o = ActorHideMethodInfo
    ResolveActorMethod "hideAll" o = ActorHideAllMethodInfo
    ResolveActorMethod "insertChildAbove" o = ActorInsertChildAboveMethodInfo
    ResolveActorMethod "insertChildAtIndex" o = ActorInsertChildAtIndexMethodInfo
    ResolveActorMethod "insertChildBelow" o = ActorInsertChildBelowMethodInfo
    ResolveActorMethod "interpolateValue" o = Clutter.Animatable.AnimatableInterpolateValueMethodInfo
    ResolveActorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveActorMethod "isInClonePaint" o = ActorIsInClonePaintMethodInfo
    ResolveActorMethod "isMapped" o = ActorIsMappedMethodInfo
    ResolveActorMethod "isRealized" o = ActorIsRealizedMethodInfo
    ResolveActorMethod "isRotated" o = ActorIsRotatedMethodInfo
    ResolveActorMethod "isScaled" o = ActorIsScaledMethodInfo
    ResolveActorMethod "isVisible" o = ActorIsVisibleMethodInfo
    ResolveActorMethod "lower" o = ActorLowerMethodInfo
    ResolveActorMethod "lowerBottom" o = ActorLowerBottomMethodInfo
    ResolveActorMethod "lowerChild" o = Clutter.Container.ContainerLowerChildMethodInfo
    ResolveActorMethod "map" o = ActorMapMethodInfo
    ResolveActorMethod "moveAnchorPoint" o = ActorMoveAnchorPointMethodInfo
    ResolveActorMethod "moveAnchorPointFromGravity" o = ActorMoveAnchorPointFromGravityMethodInfo
    ResolveActorMethod "moveBy" o = ActorMoveByMethodInfo
    ResolveActorMethod "needsExpand" o = ActorNeedsExpandMethodInfo
    ResolveActorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveActorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveActorMethod "paint" o = ActorPaintMethodInfo
    ResolveActorMethod "parseCustomNode" o = Clutter.Scriptable.ScriptableParseCustomNodeMethodInfo
    ResolveActorMethod "popInternal" o = ActorPopInternalMethodInfo
    ResolveActorMethod "pushInternal" o = ActorPushInternalMethodInfo
    ResolveActorMethod "queueRedraw" o = ActorQueueRedrawMethodInfo
    ResolveActorMethod "queueRedrawWithClip" o = ActorQueueRedrawWithClipMethodInfo
    ResolveActorMethod "queueRelayout" o = ActorQueueRelayoutMethodInfo
    ResolveActorMethod "raise" o = ActorRaiseMethodInfo
    ResolveActorMethod "raiseChild" o = Clutter.Container.ContainerRaiseChildMethodInfo
    ResolveActorMethod "raiseTop" o = ActorRaiseTopMethodInfo
    ResolveActorMethod "realize" o = ActorRealizeMethodInfo
    ResolveActorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveActorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveActorMethod "removeAction" o = ActorRemoveActionMethodInfo
    ResolveActorMethod "removeActionByName" o = ActorRemoveActionByNameMethodInfo
    ResolveActorMethod "removeActor" o = Clutter.Container.ContainerRemoveActorMethodInfo
    ResolveActorMethod "removeAllChildren" o = ActorRemoveAllChildrenMethodInfo
    ResolveActorMethod "removeAllTransitions" o = ActorRemoveAllTransitionsMethodInfo
    ResolveActorMethod "removeChild" o = ActorRemoveChildMethodInfo
    ResolveActorMethod "removeClip" o = ActorRemoveClipMethodInfo
    ResolveActorMethod "removeConstraint" o = ActorRemoveConstraintMethodInfo
    ResolveActorMethod "removeConstraintByName" o = ActorRemoveConstraintByNameMethodInfo
    ResolveActorMethod "removeEffect" o = ActorRemoveEffectMethodInfo
    ResolveActorMethod "removeEffectByName" o = ActorRemoveEffectByNameMethodInfo
    ResolveActorMethod "removeTransition" o = ActorRemoveTransitionMethodInfo
    ResolveActorMethod "reparent" o = ActorReparentMethodInfo
    ResolveActorMethod "replaceChild" o = ActorReplaceChildMethodInfo
    ResolveActorMethod "restoreEasingState" o = ActorRestoreEasingStateMethodInfo
    ResolveActorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveActorMethod "saveEasingState" o = ActorSaveEasingStateMethodInfo
    ResolveActorMethod "shouldPickPaint" o = ActorShouldPickPaintMethodInfo
    ResolveActorMethod "show" o = ActorShowMethodInfo
    ResolveActorMethod "showAll" o = ActorShowAllMethodInfo
    ResolveActorMethod "sortDepthOrder" o = Clutter.Container.ContainerSortDepthOrderMethodInfo
    ResolveActorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveActorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveActorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveActorMethod "transformStagePoint" o = ActorTransformStagePointMethodInfo
    ResolveActorMethod "unmap" o = ActorUnmapMethodInfo
    ResolveActorMethod "unparent" o = ActorUnparentMethodInfo
    ResolveActorMethod "unrealize" o = ActorUnrealizeMethodInfo
    ResolveActorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveActorMethod "unsetFlags" o = ActorUnsetFlagsMethodInfo
    ResolveActorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveActorMethod "getAbsAllocationVertices" o = ActorGetAbsAllocationVerticesMethodInfo
    ResolveActorMethod "getAccessible" o = ActorGetAccessibleMethodInfo
    ResolveActorMethod "getAction" o = ActorGetActionMethodInfo
    ResolveActorMethod "getActions" o = ActorGetActionsMethodInfo
    ResolveActorMethod "getAllocationBox" o = ActorGetAllocationBoxMethodInfo
    ResolveActorMethod "getAllocationGeometry" o = ActorGetAllocationGeometryMethodInfo
    ResolveActorMethod "getAllocationVertices" o = ActorGetAllocationVerticesMethodInfo
    ResolveActorMethod "getAnchorPoint" o = ActorGetAnchorPointMethodInfo
    ResolveActorMethod "getAnchorPointGravity" o = ActorGetAnchorPointGravityMethodInfo
    ResolveActorMethod "getAnimation" o = ActorGetAnimationMethodInfo
    ResolveActorMethod "getBackgroundColor" o = ActorGetBackgroundColorMethodInfo
    ResolveActorMethod "getChildAtIndex" o = ActorGetChildAtIndexMethodInfo
    ResolveActorMethod "getChildMeta" o = Clutter.Container.ContainerGetChildMetaMethodInfo
    ResolveActorMethod "getChildTransform" o = ActorGetChildTransformMethodInfo
    ResolveActorMethod "getChildren" o = ActorGetChildrenMethodInfo
    ResolveActorMethod "getClip" o = ActorGetClipMethodInfo
    ResolveActorMethod "getClipToAllocation" o = ActorGetClipToAllocationMethodInfo
    ResolveActorMethod "getConstraint" o = ActorGetConstraintMethodInfo
    ResolveActorMethod "getConstraints" o = ActorGetConstraintsMethodInfo
    ResolveActorMethod "getContent" o = ActorGetContentMethodInfo
    ResolveActorMethod "getContentBox" o = ActorGetContentBoxMethodInfo
    ResolveActorMethod "getContentGravity" o = ActorGetContentGravityMethodInfo
    ResolveActorMethod "getContentRepeat" o = ActorGetContentRepeatMethodInfo
    ResolveActorMethod "getContentScalingFilters" o = ActorGetContentScalingFiltersMethodInfo
    ResolveActorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveActorMethod "getDefaultPaintVolume" o = ActorGetDefaultPaintVolumeMethodInfo
    ResolveActorMethod "getDepth" o = ActorGetDepthMethodInfo
    ResolveActorMethod "getEasingDelay" o = ActorGetEasingDelayMethodInfo
    ResolveActorMethod "getEasingDuration" o = ActorGetEasingDurationMethodInfo
    ResolveActorMethod "getEasingMode" o = ActorGetEasingModeMethodInfo
    ResolveActorMethod "getEffect" o = ActorGetEffectMethodInfo
    ResolveActorMethod "getEffects" o = ActorGetEffectsMethodInfo
    ResolveActorMethod "getFirstChild" o = ActorGetFirstChildMethodInfo
    ResolveActorMethod "getFixedPositionSet" o = ActorGetFixedPositionSetMethodInfo
    ResolveActorMethod "getFlags" o = ActorGetFlagsMethodInfo
    ResolveActorMethod "getGeometry" o = ActorGetGeometryMethodInfo
    ResolveActorMethod "getGid" o = ActorGetGidMethodInfo
    ResolveActorMethod "getHeight" o = ActorGetHeightMethodInfo
    ResolveActorMethod "getId" o = Clutter.Scriptable.ScriptableGetIdMethodInfo
    ResolveActorMethod "getInitialState" o = Clutter.Animatable.AnimatableGetInitialStateMethodInfo
    ResolveActorMethod "getLastChild" o = ActorGetLastChildMethodInfo
    ResolveActorMethod "getLayoutManager" o = ActorGetLayoutManagerMethodInfo
    ResolveActorMethod "getMargin" o = ActorGetMarginMethodInfo
    ResolveActorMethod "getMarginBottom" o = ActorGetMarginBottomMethodInfo
    ResolveActorMethod "getMarginLeft" o = ActorGetMarginLeftMethodInfo
    ResolveActorMethod "getMarginRight" o = ActorGetMarginRightMethodInfo
    ResolveActorMethod "getMarginTop" o = ActorGetMarginTopMethodInfo
    ResolveActorMethod "getNChildren" o = ActorGetNChildrenMethodInfo
    ResolveActorMethod "getName" o = ActorGetNameMethodInfo
    ResolveActorMethod "getNextSibling" o = ActorGetNextSiblingMethodInfo
    ResolveActorMethod "getOffscreenRedirect" o = ActorGetOffscreenRedirectMethodInfo
    ResolveActorMethod "getOpacity" o = ActorGetOpacityMethodInfo
    ResolveActorMethod "getPaintBox" o = ActorGetPaintBoxMethodInfo
    ResolveActorMethod "getPaintOpacity" o = ActorGetPaintOpacityMethodInfo
    ResolveActorMethod "getPaintVisibility" o = ActorGetPaintVisibilityMethodInfo
    ResolveActorMethod "getPaintVolume" o = ActorGetPaintVolumeMethodInfo
    ResolveActorMethod "getPangoContext" o = ActorGetPangoContextMethodInfo
    ResolveActorMethod "getParent" o = ActorGetParentMethodInfo
    ResolveActorMethod "getPivotPoint" o = ActorGetPivotPointMethodInfo
    ResolveActorMethod "getPivotPointZ" o = ActorGetPivotPointZMethodInfo
    ResolveActorMethod "getPosition" o = ActorGetPositionMethodInfo
    ResolveActorMethod "getPreferredHeight" o = ActorGetPreferredHeightMethodInfo
    ResolveActorMethod "getPreferredSize" o = ActorGetPreferredSizeMethodInfo
    ResolveActorMethod "getPreferredWidth" o = ActorGetPreferredWidthMethodInfo
    ResolveActorMethod "getPreviousSibling" o = ActorGetPreviousSiblingMethodInfo
    ResolveActorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveActorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveActorMethod "getReactive" o = ActorGetReactiveMethodInfo
    ResolveActorMethod "getRequestMode" o = ActorGetRequestModeMethodInfo
    ResolveActorMethod "getRotation" o = ActorGetRotationMethodInfo
    ResolveActorMethod "getRotationAngle" o = ActorGetRotationAngleMethodInfo
    ResolveActorMethod "getScale" o = ActorGetScaleMethodInfo
    ResolveActorMethod "getScaleCenter" o = ActorGetScaleCenterMethodInfo
    ResolveActorMethod "getScaleGravity" o = ActorGetScaleGravityMethodInfo
    ResolveActorMethod "getScaleZ" o = ActorGetScaleZMethodInfo
    ResolveActorMethod "getShader" o = ActorGetShaderMethodInfo
    ResolveActorMethod "getSize" o = ActorGetSizeMethodInfo
    ResolveActorMethod "getStage" o = ActorGetStageMethodInfo
    ResolveActorMethod "getTextDirection" o = ActorGetTextDirectionMethodInfo
    ResolveActorMethod "getTransform" o = ActorGetTransformMethodInfo
    ResolveActorMethod "getTransformationMatrix" o = ActorGetTransformationMatrixMethodInfo
    ResolveActorMethod "getTransformedPaintVolume" o = ActorGetTransformedPaintVolumeMethodInfo
    ResolveActorMethod "getTransformedPosition" o = ActorGetTransformedPositionMethodInfo
    ResolveActorMethod "getTransformedSize" o = ActorGetTransformedSizeMethodInfo
    ResolveActorMethod "getTransition" o = ActorGetTransitionMethodInfo
    ResolveActorMethod "getTranslation" o = ActorGetTranslationMethodInfo
    ResolveActorMethod "getWidth" o = ActorGetWidthMethodInfo
    ResolveActorMethod "getX" o = ActorGetXMethodInfo
    ResolveActorMethod "getXAlign" o = ActorGetXAlignMethodInfo
    ResolveActorMethod "getXExpand" o = ActorGetXExpandMethodInfo
    ResolveActorMethod "getY" o = ActorGetYMethodInfo
    ResolveActorMethod "getYAlign" o = ActorGetYAlignMethodInfo
    ResolveActorMethod "getYExpand" o = ActorGetYExpandMethodInfo
    ResolveActorMethod "getZPosition" o = ActorGetZPositionMethodInfo
    ResolveActorMethod "getZRotationGravity" o = ActorGetZRotationGravityMethodInfo
    ResolveActorMethod "setAllocation" o = ActorSetAllocationMethodInfo
    ResolveActorMethod "setAnchorPoint" o = ActorSetAnchorPointMethodInfo
    ResolveActorMethod "setAnchorPointFromGravity" o = ActorSetAnchorPointFromGravityMethodInfo
    ResolveActorMethod "setBackgroundColor" o = ActorSetBackgroundColorMethodInfo
    ResolveActorMethod "setChildAboveSibling" o = ActorSetChildAboveSiblingMethodInfo
    ResolveActorMethod "setChildAtIndex" o = ActorSetChildAtIndexMethodInfo
    ResolveActorMethod "setChildBelowSibling" o = ActorSetChildBelowSiblingMethodInfo
    ResolveActorMethod "setChildTransform" o = ActorSetChildTransformMethodInfo
    ResolveActorMethod "setClip" o = ActorSetClipMethodInfo
    ResolveActorMethod "setClipToAllocation" o = ActorSetClipToAllocationMethodInfo
    ResolveActorMethod "setContent" o = ActorSetContentMethodInfo
    ResolveActorMethod "setContentGravity" o = ActorSetContentGravityMethodInfo
    ResolveActorMethod "setContentRepeat" o = ActorSetContentRepeatMethodInfo
    ResolveActorMethod "setContentScalingFilters" o = ActorSetContentScalingFiltersMethodInfo
    ResolveActorMethod "setCustomProperty" o = Clutter.Scriptable.ScriptableSetCustomPropertyMethodInfo
    ResolveActorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveActorMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveActorMethod "setDepth" o = ActorSetDepthMethodInfo
    ResolveActorMethod "setEasingDelay" o = ActorSetEasingDelayMethodInfo
    ResolveActorMethod "setEasingDuration" o = ActorSetEasingDurationMethodInfo
    ResolveActorMethod "setEasingMode" o = ActorSetEasingModeMethodInfo
    ResolveActorMethod "setFinalState" o = Clutter.Animatable.AnimatableSetFinalStateMethodInfo
    ResolveActorMethod "setFixedPositionSet" o = ActorSetFixedPositionSetMethodInfo
    ResolveActorMethod "setFlags" o = ActorSetFlagsMethodInfo
    ResolveActorMethod "setGeometry" o = ActorSetGeometryMethodInfo
    ResolveActorMethod "setHeight" o = ActorSetHeightMethodInfo
    ResolveActorMethod "setId" o = Clutter.Scriptable.ScriptableSetIdMethodInfo
    ResolveActorMethod "setLayoutManager" o = ActorSetLayoutManagerMethodInfo
    ResolveActorMethod "setMargin" o = ActorSetMarginMethodInfo
    ResolveActorMethod "setMarginBottom" o = ActorSetMarginBottomMethodInfo
    ResolveActorMethod "setMarginLeft" o = ActorSetMarginLeftMethodInfo
    ResolveActorMethod "setMarginRight" o = ActorSetMarginRightMethodInfo
    ResolveActorMethod "setMarginTop" o = ActorSetMarginTopMethodInfo
    ResolveActorMethod "setName" o = ActorSetNameMethodInfo
    ResolveActorMethod "setOffscreenRedirect" o = ActorSetOffscreenRedirectMethodInfo
    ResolveActorMethod "setOpacity" o = ActorSetOpacityMethodInfo
    ResolveActorMethod "setParent" o = ActorSetParentMethodInfo
    ResolveActorMethod "setPivotPoint" o = ActorSetPivotPointMethodInfo
    ResolveActorMethod "setPivotPointZ" o = ActorSetPivotPointZMethodInfo
    ResolveActorMethod "setPosition" o = ActorSetPositionMethodInfo
    ResolveActorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveActorMethod "setReactive" o = ActorSetReactiveMethodInfo
    ResolveActorMethod "setRequestMode" o = ActorSetRequestModeMethodInfo
    ResolveActorMethod "setRotation" o = ActorSetRotationMethodInfo
    ResolveActorMethod "setRotationAngle" o = ActorSetRotationAngleMethodInfo
    ResolveActorMethod "setScale" o = ActorSetScaleMethodInfo
    ResolveActorMethod "setScaleFull" o = ActorSetScaleFullMethodInfo
    ResolveActorMethod "setScaleWithGravity" o = ActorSetScaleWithGravityMethodInfo
    ResolveActorMethod "setScaleZ" o = ActorSetScaleZMethodInfo
    ResolveActorMethod "setShader" o = ActorSetShaderMethodInfo
    ResolveActorMethod "setShaderParam" o = ActorSetShaderParamMethodInfo
    ResolveActorMethod "setShaderParamFloat" o = ActorSetShaderParamFloatMethodInfo
    ResolveActorMethod "setShaderParamInt" o = ActorSetShaderParamIntMethodInfo
    ResolveActorMethod "setSize" o = ActorSetSizeMethodInfo
    ResolveActorMethod "setTextDirection" o = ActorSetTextDirectionMethodInfo
    ResolveActorMethod "setTransform" o = ActorSetTransformMethodInfo
    ResolveActorMethod "setTranslation" o = ActorSetTranslationMethodInfo
    ResolveActorMethod "setWidth" o = ActorSetWidthMethodInfo
    ResolveActorMethod "setX" o = ActorSetXMethodInfo
    ResolveActorMethod "setXAlign" o = ActorSetXAlignMethodInfo
    ResolveActorMethod "setXExpand" o = ActorSetXExpandMethodInfo
    ResolveActorMethod "setY" o = ActorSetYMethodInfo
    ResolveActorMethod "setYAlign" o = ActorSetYAlignMethodInfo
    ResolveActorMethod "setYExpand" o = ActorSetYExpandMethodInfo
    ResolveActorMethod "setZPosition" o = ActorSetZPositionMethodInfo
    ResolveActorMethod "setZRotationFromGravity" o = ActorSetZRotationFromGravityMethodInfo
    ResolveActorMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveActorMethod t Actor, O.OverloadedMethod info Actor p) => OL.IsLabel t (Actor -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveActorMethod t Actor, O.OverloadedMethod info Actor p, R.HasField t Actor p) => R.HasField t Actor p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveActorMethod t Actor, O.OverloadedMethodInfo info Actor) => OL.IsLabel t (O.MethodProxy info Actor) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal Actor::allocation-changed
-- | The [allocationChanged](#g:signal:allocationChanged) signal is emitted when the
-- [Actor:allocation]("GI.Clutter.Objects.Actor#g:attr: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/
type ActorAllocationChangedCallback =
    Clutter.ActorBox.ActorBox
    -- ^ /@box@/: a t'GI.Clutter.Structs.ActorBox.ActorBox' with the new allocation
    -> [Clutter.Flags.AllocationFlags]
    -- ^ /@flags@/: t'GI.Clutter.Flags.AllocationFlags' for the allocation
    -> IO ()

type C_ActorAllocationChangedCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.ActorBox.ActorBox ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorAllocationChangedCallback`.
foreign import ccall "wrapper"
    mk_ActorAllocationChangedCallback :: C_ActorAllocationChangedCallback -> IO (FunPtr C_ActorAllocationChangedCallback)

wrap_ActorAllocationChangedCallback :: 
    GObject a => (a -> ActorAllocationChangedCallback) ->
    C_ActorAllocationChangedCallback
wrap_ActorAllocationChangedCallback :: forall a.
GObject a =>
(a -> ActorAllocationChangedCallback)
-> C_ActorAllocationChangedCallback
wrap_ActorAllocationChangedCallback a -> ActorAllocationChangedCallback
gi'cb Ptr Actor
gi'selfPtr Ptr ActorBox
box CUInt
flags Ptr ()
_ = do
    Ptr ActorBox -> (ActorBox -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr ActorBox
box ((ActorBox -> IO ()) -> IO ()) -> (ActorBox -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ActorBox
box' -> do
        let flags' :: [AllocationFlags]
flags' = CUInt -> [AllocationFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
flags
        Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorAllocationChangedCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  ActorBox
box' [AllocationFlags]
flags'


-- | Connect a signal handler for the [allocationChanged](#signal:allocationChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #allocationChanged callback
-- @
-- 
-- 
onActorAllocationChanged :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorAllocationChangedCallback) -> m SignalHandlerId
onActorAllocationChanged :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorAllocationChangedCallback)
-> m SignalHandlerId
onActorAllocationChanged a
obj (?self::a) => ActorAllocationChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorAllocationChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorAllocationChangedCallback
ActorAllocationChangedCallback
cb
    let wrapped' :: C_ActorAllocationChangedCallback
wrapped' = (a -> ActorAllocationChangedCallback)
-> C_ActorAllocationChangedCallback
forall a.
GObject a =>
(a -> ActorAllocationChangedCallback)
-> C_ActorAllocationChangedCallback
wrap_ActorAllocationChangedCallback a -> ActorAllocationChangedCallback
wrapped
    FunPtr C_ActorAllocationChangedCallback
wrapped'' <- C_ActorAllocationChangedCallback
-> IO (FunPtr C_ActorAllocationChangedCallback)
mk_ActorAllocationChangedCallback C_ActorAllocationChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorAllocationChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"allocation-changed" FunPtr C_ActorAllocationChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [allocationChanged](#signal:allocationChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorAllocationChanged :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorAllocationChangedCallback) -> m SignalHandlerId
afterActorAllocationChanged :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorAllocationChangedCallback)
-> m SignalHandlerId
afterActorAllocationChanged a
obj (?self::a) => ActorAllocationChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorAllocationChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorAllocationChangedCallback
ActorAllocationChangedCallback
cb
    let wrapped' :: C_ActorAllocationChangedCallback
wrapped' = (a -> ActorAllocationChangedCallback)
-> C_ActorAllocationChangedCallback
forall a.
GObject a =>
(a -> ActorAllocationChangedCallback)
-> C_ActorAllocationChangedCallback
wrap_ActorAllocationChangedCallback a -> ActorAllocationChangedCallback
wrapped
    FunPtr C_ActorAllocationChangedCallback
wrapped'' <- C_ActorAllocationChangedCallback
-> IO (FunPtr C_ActorAllocationChangedCallback)
mk_ActorAllocationChangedCallback C_ActorAllocationChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorAllocationChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"allocation-changed" FunPtr C_ActorAllocationChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorAllocationChangedSignalInfo
instance SignalInfo ActorAllocationChangedSignalInfo where
    type HaskellCallbackType ActorAllocationChangedSignalInfo = ActorAllocationChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorAllocationChangedCallback cb
        cb'' <- mk_ActorAllocationChangedCallback cb'
        connectSignalFunPtr obj "allocation-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::allocation-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:allocationChanged"})

#endif

-- signal Actor::button-press-event
-- | The [buttonPressEvent](#g:signal:buttonPressEvent) signal is emitted each time a mouse button
-- is pressed on /@actor@/.
-- 
-- /Since: 0.6/
type ActorButtonPressEventCallback =
    Clutter.ButtonEvent.ButtonEvent
    -- ^ /@event@/: a t'GI.Clutter.Structs.ButtonEvent.ButtonEvent'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorButtonPressEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.ButtonEvent.ButtonEvent ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorButtonPressEventCallback`.
foreign import ccall "wrapper"
    mk_ActorButtonPressEventCallback :: C_ActorButtonPressEventCallback -> IO (FunPtr C_ActorButtonPressEventCallback)

wrap_ActorButtonPressEventCallback :: 
    GObject a => (a -> ActorButtonPressEventCallback) ->
    C_ActorButtonPressEventCallback
wrap_ActorButtonPressEventCallback :: forall a.
GObject a =>
(a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
wrap_ActorButtonPressEventCallback a -> ActorButtonPressEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr ButtonEvent
event Ptr ()
_ = do
    ButtonEvent
event' <- ((ManagedPtr ButtonEvent -> ButtonEvent)
-> Ptr ButtonEvent -> IO ButtonEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ButtonEvent -> ButtonEvent
Clutter.ButtonEvent.ButtonEvent) Ptr ButtonEvent
event
    Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorButtonPressEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  ButtonEvent
event'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [buttonPressEvent](#signal:buttonPressEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #buttonPressEvent callback
-- @
-- 
-- 
onActorButtonPressEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorButtonPressEventCallback) -> m SignalHandlerId
onActorButtonPressEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorButtonPressEventCallback)
-> m SignalHandlerId
onActorButtonPressEvent a
obj (?self::a) => ActorButtonPressEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorButtonPressEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorButtonPressEventCallback
ActorButtonPressEventCallback
cb
    let wrapped' :: C_ActorButtonPressEventCallback
wrapped' = (a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
forall a.
GObject a =>
(a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
wrap_ActorButtonPressEventCallback a -> ActorButtonPressEventCallback
wrapped
    FunPtr C_ActorButtonPressEventCallback
wrapped'' <- C_ActorButtonPressEventCallback
-> IO (FunPtr C_ActorButtonPressEventCallback)
mk_ActorButtonPressEventCallback C_ActorButtonPressEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorButtonPressEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"button-press-event" FunPtr C_ActorButtonPressEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [buttonPressEvent](#signal:buttonPressEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorButtonPressEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorButtonPressEventCallback) -> m SignalHandlerId
afterActorButtonPressEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorButtonPressEventCallback)
-> m SignalHandlerId
afterActorButtonPressEvent a
obj (?self::a) => ActorButtonPressEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorButtonPressEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorButtonPressEventCallback
ActorButtonPressEventCallback
cb
    let wrapped' :: C_ActorButtonPressEventCallback
wrapped' = (a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
forall a.
GObject a =>
(a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
wrap_ActorButtonPressEventCallback a -> ActorButtonPressEventCallback
wrapped
    FunPtr C_ActorButtonPressEventCallback
wrapped'' <- C_ActorButtonPressEventCallback
-> IO (FunPtr C_ActorButtonPressEventCallback)
mk_ActorButtonPressEventCallback C_ActorButtonPressEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorButtonPressEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"button-press-event" FunPtr C_ActorButtonPressEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorButtonPressEventSignalInfo
instance SignalInfo ActorButtonPressEventSignalInfo where
    type HaskellCallbackType ActorButtonPressEventSignalInfo = ActorButtonPressEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorButtonPressEventCallback cb
        cb'' <- mk_ActorButtonPressEventCallback cb'
        connectSignalFunPtr obj "button-press-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::button-press-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:buttonPressEvent"})

#endif

-- signal Actor::button-release-event
-- | The [buttonReleaseEvent](#g:signal:buttonReleaseEvent) signal is emitted each time a mouse button
-- is released on /@actor@/.
-- 
-- /Since: 0.6/
type ActorButtonReleaseEventCallback =
    Clutter.ButtonEvent.ButtonEvent
    -- ^ /@event@/: a t'GI.Clutter.Structs.ButtonEvent.ButtonEvent'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorButtonReleaseEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.ButtonEvent.ButtonEvent ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorButtonReleaseEventCallback`.
foreign import ccall "wrapper"
    mk_ActorButtonReleaseEventCallback :: C_ActorButtonReleaseEventCallback -> IO (FunPtr C_ActorButtonReleaseEventCallback)

wrap_ActorButtonReleaseEventCallback :: 
    GObject a => (a -> ActorButtonReleaseEventCallback) ->
    C_ActorButtonReleaseEventCallback
wrap_ActorButtonReleaseEventCallback :: forall a.
GObject a =>
(a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
wrap_ActorButtonReleaseEventCallback a -> ActorButtonPressEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr ButtonEvent
event Ptr ()
_ = do
    ButtonEvent
event' <- ((ManagedPtr ButtonEvent -> ButtonEvent)
-> Ptr ButtonEvent -> IO ButtonEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ButtonEvent -> ButtonEvent
Clutter.ButtonEvent.ButtonEvent) Ptr ButtonEvent
event
    Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorButtonPressEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  ButtonEvent
event'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [buttonReleaseEvent](#signal:buttonReleaseEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #buttonReleaseEvent callback
-- @
-- 
-- 
onActorButtonReleaseEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorButtonReleaseEventCallback) -> m SignalHandlerId
onActorButtonReleaseEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorButtonPressEventCallback)
-> m SignalHandlerId
onActorButtonReleaseEvent a
obj (?self::a) => ActorButtonPressEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorButtonPressEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorButtonPressEventCallback
ActorButtonPressEventCallback
cb
    let wrapped' :: C_ActorButtonPressEventCallback
wrapped' = (a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
forall a.
GObject a =>
(a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
wrap_ActorButtonReleaseEventCallback a -> ActorButtonPressEventCallback
wrapped
    FunPtr C_ActorButtonPressEventCallback
wrapped'' <- C_ActorButtonPressEventCallback
-> IO (FunPtr C_ActorButtonPressEventCallback)
mk_ActorButtonReleaseEventCallback C_ActorButtonPressEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorButtonPressEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"button-release-event" FunPtr C_ActorButtonPressEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [buttonReleaseEvent](#signal:buttonReleaseEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorButtonReleaseEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorButtonReleaseEventCallback) -> m SignalHandlerId
afterActorButtonReleaseEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorButtonPressEventCallback)
-> m SignalHandlerId
afterActorButtonReleaseEvent a
obj (?self::a) => ActorButtonPressEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorButtonPressEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorButtonPressEventCallback
ActorButtonPressEventCallback
cb
    let wrapped' :: C_ActorButtonPressEventCallback
wrapped' = (a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
forall a.
GObject a =>
(a -> ActorButtonPressEventCallback)
-> C_ActorButtonPressEventCallback
wrap_ActorButtonReleaseEventCallback a -> ActorButtonPressEventCallback
wrapped
    FunPtr C_ActorButtonPressEventCallback
wrapped'' <- C_ActorButtonPressEventCallback
-> IO (FunPtr C_ActorButtonPressEventCallback)
mk_ActorButtonReleaseEventCallback C_ActorButtonPressEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorButtonPressEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"button-release-event" FunPtr C_ActorButtonPressEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorButtonReleaseEventSignalInfo
instance SignalInfo ActorButtonReleaseEventSignalInfo where
    type HaskellCallbackType ActorButtonReleaseEventSignalInfo = ActorButtonReleaseEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorButtonReleaseEventCallback cb
        cb'' <- mk_ActorButtonReleaseEventCallback cb'
        connectSignalFunPtr obj "button-release-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::button-release-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:buttonReleaseEvent"})

#endif

-- signal Actor::captured-event
-- | The [capturedEvent](#g:signal:capturedEvent) signal is emitted when an event is captured
-- by Clutter. This signal will be emitted starting from the top-level
-- container (the t'GI.Clutter.Objects.Stage.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](#g:signal:keyReleasedEvent)) are
-- emitted.
-- 
-- /Since: 0.6/
type ActorCapturedEventCallback =
    Clutter.Event.Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorCapturedEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.Event.Event ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorCapturedEventCallback`.
foreign import ccall "wrapper"
    mk_ActorCapturedEventCallback :: C_ActorCapturedEventCallback -> IO (FunPtr C_ActorCapturedEventCallback)

wrap_ActorCapturedEventCallback :: 
    GObject a => (a -> ActorCapturedEventCallback) ->
    C_ActorCapturedEventCallback
wrap_ActorCapturedEventCallback :: forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorCapturedEventCallback a -> ActorCapturedEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr Event
event Ptr ()
_ = do
    Ptr Event -> (Event -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Event
event ((Event -> IO CInt) -> IO CInt) -> (Event -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Event
event' -> do
        Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorCapturedEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  Event
event'
        let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
        CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [capturedEvent](#signal:capturedEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #capturedEvent callback
-- @
-- 
-- 
onActorCapturedEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorCapturedEventCallback) -> m SignalHandlerId
onActorCapturedEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorCapturedEventCallback) -> m SignalHandlerId
onActorCapturedEvent a
obj (?self::a) => ActorCapturedEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorCapturedEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorCapturedEventCallback
ActorCapturedEventCallback
cb
    let wrapped' :: C_ActorCapturedEventCallback
wrapped' = (a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorCapturedEventCallback a -> ActorCapturedEventCallback
wrapped
    FunPtr C_ActorCapturedEventCallback
wrapped'' <- C_ActorCapturedEventCallback
-> IO (FunPtr C_ActorCapturedEventCallback)
mk_ActorCapturedEventCallback C_ActorCapturedEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorCapturedEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"captured-event" FunPtr C_ActorCapturedEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [capturedEvent](#signal:capturedEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorCapturedEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorCapturedEventCallback) -> m SignalHandlerId
afterActorCapturedEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorCapturedEventCallback) -> m SignalHandlerId
afterActorCapturedEvent a
obj (?self::a) => ActorCapturedEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorCapturedEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorCapturedEventCallback
ActorCapturedEventCallback
cb
    let wrapped' :: C_ActorCapturedEventCallback
wrapped' = (a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorCapturedEventCallback a -> ActorCapturedEventCallback
wrapped
    FunPtr C_ActorCapturedEventCallback
wrapped'' <- C_ActorCapturedEventCallback
-> IO (FunPtr C_ActorCapturedEventCallback)
mk_ActorCapturedEventCallback C_ActorCapturedEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorCapturedEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"captured-event" FunPtr C_ActorCapturedEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorCapturedEventSignalInfo
instance SignalInfo ActorCapturedEventSignalInfo where
    type HaskellCallbackType ActorCapturedEventSignalInfo = ActorCapturedEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorCapturedEventCallback cb
        cb'' <- mk_ActorCapturedEventCallback cb'
        connectSignalFunPtr obj "captured-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::captured-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:capturedEvent"})

#endif

-- signal Actor::destroy
-- | The [destroy](#g:signal:destroy) signal notifies that all references held on the
-- actor which emitted it should be released.
-- 
-- The [destroy](#g:signal:destroy) signal should be used by all holders of a reference
-- on /@actor@/.
-- 
-- This signal might result in the finalization of the t'GI.Clutter.Objects.Actor.Actor'
-- if all references are released.
-- 
-- Composite actors and actors implementing the t'GI.Clutter.Interfaces.Container.Container'
-- interface should override the default implementation of the
-- class handler of this signal and call 'GI.Clutter.Objects.Actor.actorDestroy' on
-- their children. When overriding the default class handler, it is
-- required to chain up to the parent\'s implementation.
-- 
-- /Since: 0.2/
type ActorDestroyCallback =
    IO ()

type C_ActorDestroyCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorDestroyCallback`.
foreign import ccall "wrapper"
    mk_ActorDestroyCallback :: C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)

wrap_ActorDestroyCallback :: 
    GObject a => (a -> ActorDestroyCallback) ->
    C_ActorDestroyCallback
wrap_ActorDestroyCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorDestroyCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [destroy](#signal:destroy) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #destroy callback
-- @
-- 
-- 
onActorDestroy :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorDestroyCallback) -> m SignalHandlerId
onActorDestroy :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorDestroy a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorDestroyCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorDestroyCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"destroy" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [destroy](#signal:destroy) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorDestroy :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorDestroyCallback) -> m SignalHandlerId
afterActorDestroy :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorDestroy a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorDestroyCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorDestroyCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"destroy" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorDestroySignalInfo
instance SignalInfo ActorDestroySignalInfo where
    type HaskellCallbackType ActorDestroySignalInfo = ActorDestroyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorDestroyCallback cb
        cb'' <- mk_ActorDestroyCallback cb'
        connectSignalFunPtr obj "destroy" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::destroy"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:destroy"})

#endif

-- signal Actor::enter-event
-- | The [enterEvent](#g:signal:enterEvent) signal is emitted when the pointer enters the /@actor@/
-- 
-- /Since: 0.6/
type ActorEnterEventCallback =
    Clutter.CrossingEvent.CrossingEvent
    -- ^ /@event@/: a t'GI.Clutter.Structs.CrossingEvent.CrossingEvent'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorEnterEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.CrossingEvent.CrossingEvent ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorEnterEventCallback`.
foreign import ccall "wrapper"
    mk_ActorEnterEventCallback :: C_ActorEnterEventCallback -> IO (FunPtr C_ActorEnterEventCallback)

wrap_ActorEnterEventCallback :: 
    GObject a => (a -> ActorEnterEventCallback) ->
    C_ActorEnterEventCallback
wrap_ActorEnterEventCallback :: forall a.
GObject a =>
(a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
wrap_ActorEnterEventCallback a -> ActorEnterEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr CrossingEvent
event Ptr ()
_ = do
    CrossingEvent
event' <- ((ManagedPtr CrossingEvent -> CrossingEvent)
-> Ptr CrossingEvent -> IO CrossingEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CrossingEvent -> CrossingEvent
Clutter.CrossingEvent.CrossingEvent) Ptr CrossingEvent
event
    Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorEnterEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  CrossingEvent
event'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [enterEvent](#signal:enterEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #enterEvent callback
-- @
-- 
-- 
onActorEnterEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorEnterEventCallback) -> m SignalHandlerId
onActorEnterEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorEnterEventCallback) -> m SignalHandlerId
onActorEnterEvent a
obj (?self::a) => ActorEnterEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorEnterEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorEnterEventCallback
ActorEnterEventCallback
cb
    let wrapped' :: C_ActorEnterEventCallback
wrapped' = (a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
forall a.
GObject a =>
(a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
wrap_ActorEnterEventCallback a -> ActorEnterEventCallback
wrapped
    FunPtr C_ActorEnterEventCallback
wrapped'' <- C_ActorEnterEventCallback -> IO (FunPtr C_ActorEnterEventCallback)
mk_ActorEnterEventCallback C_ActorEnterEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorEnterEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enter-event" FunPtr C_ActorEnterEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [enterEvent](#signal:enterEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorEnterEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorEnterEventCallback) -> m SignalHandlerId
afterActorEnterEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorEnterEventCallback) -> m SignalHandlerId
afterActorEnterEvent a
obj (?self::a) => ActorEnterEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorEnterEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorEnterEventCallback
ActorEnterEventCallback
cb
    let wrapped' :: C_ActorEnterEventCallback
wrapped' = (a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
forall a.
GObject a =>
(a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
wrap_ActorEnterEventCallback a -> ActorEnterEventCallback
wrapped
    FunPtr C_ActorEnterEventCallback
wrapped'' <- C_ActorEnterEventCallback -> IO (FunPtr C_ActorEnterEventCallback)
mk_ActorEnterEventCallback C_ActorEnterEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorEnterEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enter-event" FunPtr C_ActorEnterEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorEnterEventSignalInfo
instance SignalInfo ActorEnterEventSignalInfo where
    type HaskellCallbackType ActorEnterEventSignalInfo = ActorEnterEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorEnterEventCallback cb
        cb'' <- mk_ActorEnterEventCallback cb'
        connectSignalFunPtr obj "enter-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::enter-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:enterEvent"})

#endif

-- signal Actor::event
-- | The [event](#g:signal: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 t'GI.Clutter.Objects.Stage.Stage').
-- 
-- /Since: 0.6/
type ActorEventCallback =
    Clutter.Event.Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.Event.Event ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorEventCallback`.
foreign import ccall "wrapper"
    mk_ActorEventCallback :: C_ActorEventCallback -> IO (FunPtr C_ActorEventCallback)

wrap_ActorEventCallback :: 
    GObject a => (a -> ActorEventCallback) ->
    C_ActorEventCallback
wrap_ActorEventCallback :: forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorEventCallback a -> ActorCapturedEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr Event
event Ptr ()
_ = do
    Ptr Event -> (Event -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Event
event ((Event -> IO CInt) -> IO CInt) -> (Event -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Event
event' -> do
        Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorCapturedEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  Event
event'
        let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
        CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [event](#signal:event) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #event callback
-- @
-- 
-- 
onActorEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorEventCallback) -> m SignalHandlerId
onActorEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorCapturedEventCallback) -> m SignalHandlerId
onActorEvent a
obj (?self::a) => ActorCapturedEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorCapturedEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorCapturedEventCallback
ActorCapturedEventCallback
cb
    let wrapped' :: C_ActorCapturedEventCallback
wrapped' = (a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorEventCallback a -> ActorCapturedEventCallback
wrapped
    FunPtr C_ActorCapturedEventCallback
wrapped'' <- C_ActorCapturedEventCallback
-> IO (FunPtr C_ActorCapturedEventCallback)
mk_ActorEventCallback C_ActorCapturedEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorCapturedEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"event" FunPtr C_ActorCapturedEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [event](#signal:event) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorEventCallback) -> m SignalHandlerId
afterActorEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorCapturedEventCallback) -> m SignalHandlerId
afterActorEvent a
obj (?self::a) => ActorCapturedEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorCapturedEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorCapturedEventCallback
ActorCapturedEventCallback
cb
    let wrapped' :: C_ActorCapturedEventCallback
wrapped' = (a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorEventCallback a -> ActorCapturedEventCallback
wrapped
    FunPtr C_ActorCapturedEventCallback
wrapped'' <- C_ActorCapturedEventCallback
-> IO (FunPtr C_ActorCapturedEventCallback)
mk_ActorEventCallback C_ActorCapturedEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorCapturedEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"event" FunPtr C_ActorCapturedEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorEventSignalInfo
instance SignalInfo ActorEventSignalInfo where
    type HaskellCallbackType ActorEventSignalInfo = ActorEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorEventCallback cb
        cb'' <- mk_ActorEventCallback cb'
        connectSignalFunPtr obj "event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:event"})

#endif

-- signal Actor::hide
-- | The [hide](#g:signal:hide) signal is emitted when an actor is no longer rendered
-- on the stage.
-- 
-- /Since: 0.2/
type ActorHideCallback =
    IO ()

type C_ActorHideCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorHideCallback`.
foreign import ccall "wrapper"
    mk_ActorHideCallback :: C_ActorHideCallback -> IO (FunPtr C_ActorHideCallback)

wrap_ActorHideCallback :: 
    GObject a => (a -> ActorHideCallback) ->
    C_ActorHideCallback
wrap_ActorHideCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorHideCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [hide](#signal:hide) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #hide callback
-- @
-- 
-- 
onActorHide :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorHideCallback) -> m SignalHandlerId
onActorHide :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorHide a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorHideCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorHideCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [hide](#signal:hide) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorHide :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorHideCallback) -> m SignalHandlerId
afterActorHide :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorHide a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorHideCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorHideCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorHideSignalInfo
instance SignalInfo ActorHideSignalInfo where
    type HaskellCallbackType ActorHideSignalInfo = ActorHideCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorHideCallback cb
        cb'' <- mk_ActorHideCallback cb'
        connectSignalFunPtr obj "hide" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::hide"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:hide"})

#endif

-- signal Actor::key-focus-in
-- | The [keyFocusIn](#g:signal:keyFocusIn) signal is emitted when /@actor@/ receives key focus.
-- 
-- /Since: 0.6/
type ActorKeyFocusInCallback =
    IO ()

type C_ActorKeyFocusInCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorKeyFocusInCallback`.
foreign import ccall "wrapper"
    mk_ActorKeyFocusInCallback :: C_ActorKeyFocusInCallback -> IO (FunPtr C_ActorKeyFocusInCallback)

wrap_ActorKeyFocusInCallback :: 
    GObject a => (a -> ActorKeyFocusInCallback) ->
    C_ActorKeyFocusInCallback
wrap_ActorKeyFocusInCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorKeyFocusInCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [keyFocusIn](#signal:keyFocusIn) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #keyFocusIn callback
-- @
-- 
-- 
onActorKeyFocusIn :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyFocusInCallback) -> m SignalHandlerId
onActorKeyFocusIn :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorKeyFocusIn a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorKeyFocusInCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorKeyFocusInCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-focus-in" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [keyFocusIn](#signal:keyFocusIn) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorKeyFocusIn :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyFocusInCallback) -> m SignalHandlerId
afterActorKeyFocusIn :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorKeyFocusIn a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorKeyFocusInCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorKeyFocusInCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-focus-in" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorKeyFocusInSignalInfo
instance SignalInfo ActorKeyFocusInSignalInfo where
    type HaskellCallbackType ActorKeyFocusInSignalInfo = ActorKeyFocusInCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorKeyFocusInCallback cb
        cb'' <- mk_ActorKeyFocusInCallback cb'
        connectSignalFunPtr obj "key-focus-in" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::key-focus-in"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:keyFocusIn"})

#endif

-- signal Actor::key-focus-out
-- | The [keyFocusOut](#g:signal:keyFocusOut) signal is emitted when /@actor@/ loses key focus.
-- 
-- /Since: 0.6/
type ActorKeyFocusOutCallback =
    IO ()

type C_ActorKeyFocusOutCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorKeyFocusOutCallback`.
foreign import ccall "wrapper"
    mk_ActorKeyFocusOutCallback :: C_ActorKeyFocusOutCallback -> IO (FunPtr C_ActorKeyFocusOutCallback)

wrap_ActorKeyFocusOutCallback :: 
    GObject a => (a -> ActorKeyFocusOutCallback) ->
    C_ActorKeyFocusOutCallback
wrap_ActorKeyFocusOutCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorKeyFocusOutCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [keyFocusOut](#signal:keyFocusOut) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #keyFocusOut callback
-- @
-- 
-- 
onActorKeyFocusOut :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyFocusOutCallback) -> m SignalHandlerId
onActorKeyFocusOut :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorKeyFocusOut a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorKeyFocusOutCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorKeyFocusOutCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-focus-out" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [keyFocusOut](#signal:keyFocusOut) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorKeyFocusOut :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyFocusOutCallback) -> m SignalHandlerId
afterActorKeyFocusOut :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorKeyFocusOut a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorKeyFocusOutCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorKeyFocusOutCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-focus-out" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorKeyFocusOutSignalInfo
instance SignalInfo ActorKeyFocusOutSignalInfo where
    type HaskellCallbackType ActorKeyFocusOutSignalInfo = ActorKeyFocusOutCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorKeyFocusOutCallback cb
        cb'' <- mk_ActorKeyFocusOutCallback cb'
        connectSignalFunPtr obj "key-focus-out" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::key-focus-out"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:keyFocusOut"})

#endif

-- signal Actor::key-press-event
-- | The [keyPressEvent](#g:signal:keyPressEvent) signal is emitted each time a keyboard button
-- is pressed while /@actor@/ has key focus (see 'GI.Clutter.Objects.Stage.stageSetKeyFocus').
-- 
-- /Since: 0.6/
type ActorKeyPressEventCallback =
    Clutter.KeyEvent.KeyEvent
    -- ^ /@event@/: a t'GI.Clutter.Structs.KeyEvent.KeyEvent'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorKeyPressEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.KeyEvent.KeyEvent ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorKeyPressEventCallback`.
foreign import ccall "wrapper"
    mk_ActorKeyPressEventCallback :: C_ActorKeyPressEventCallback -> IO (FunPtr C_ActorKeyPressEventCallback)

wrap_ActorKeyPressEventCallback :: 
    GObject a => (a -> ActorKeyPressEventCallback) ->
    C_ActorKeyPressEventCallback
wrap_ActorKeyPressEventCallback :: forall a.
GObject a =>
(a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
wrap_ActorKeyPressEventCallback a -> ActorKeyPressEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr KeyEvent
event Ptr ()
_ = do
    KeyEvent
event' <- ((ManagedPtr KeyEvent -> KeyEvent) -> Ptr KeyEvent -> IO KeyEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr KeyEvent -> KeyEvent
Clutter.KeyEvent.KeyEvent) Ptr KeyEvent
event
    Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorKeyPressEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  KeyEvent
event'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [keyPressEvent](#signal:keyPressEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #keyPressEvent callback
-- @
-- 
-- 
onActorKeyPressEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyPressEventCallback) -> m SignalHandlerId
onActorKeyPressEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorKeyPressEventCallback) -> m SignalHandlerId
onActorKeyPressEvent a
obj (?self::a) => ActorKeyPressEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorKeyPressEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorKeyPressEventCallback
ActorKeyPressEventCallback
cb
    let wrapped' :: C_ActorKeyPressEventCallback
wrapped' = (a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
forall a.
GObject a =>
(a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
wrap_ActorKeyPressEventCallback a -> ActorKeyPressEventCallback
wrapped
    FunPtr C_ActorKeyPressEventCallback
wrapped'' <- C_ActorKeyPressEventCallback
-> IO (FunPtr C_ActorKeyPressEventCallback)
mk_ActorKeyPressEventCallback C_ActorKeyPressEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorKeyPressEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-press-event" FunPtr C_ActorKeyPressEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [keyPressEvent](#signal:keyPressEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorKeyPressEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyPressEventCallback) -> m SignalHandlerId
afterActorKeyPressEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorKeyPressEventCallback) -> m SignalHandlerId
afterActorKeyPressEvent a
obj (?self::a) => ActorKeyPressEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorKeyPressEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorKeyPressEventCallback
ActorKeyPressEventCallback
cb
    let wrapped' :: C_ActorKeyPressEventCallback
wrapped' = (a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
forall a.
GObject a =>
(a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
wrap_ActorKeyPressEventCallback a -> ActorKeyPressEventCallback
wrapped
    FunPtr C_ActorKeyPressEventCallback
wrapped'' <- C_ActorKeyPressEventCallback
-> IO (FunPtr C_ActorKeyPressEventCallback)
mk_ActorKeyPressEventCallback C_ActorKeyPressEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorKeyPressEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-press-event" FunPtr C_ActorKeyPressEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorKeyPressEventSignalInfo
instance SignalInfo ActorKeyPressEventSignalInfo where
    type HaskellCallbackType ActorKeyPressEventSignalInfo = ActorKeyPressEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorKeyPressEventCallback cb
        cb'' <- mk_ActorKeyPressEventCallback cb'
        connectSignalFunPtr obj "key-press-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::key-press-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:keyPressEvent"})

#endif

-- signal Actor::key-release-event
-- | The [keyReleaseEvent](#g:signal:keyReleaseEvent) signal is emitted each time a keyboard button
-- is released while /@actor@/ has key focus (see
-- 'GI.Clutter.Objects.Stage.stageSetKeyFocus').
-- 
-- /Since: 0.6/
type ActorKeyReleaseEventCallback =
    Clutter.KeyEvent.KeyEvent
    -- ^ /@event@/: a t'GI.Clutter.Structs.KeyEvent.KeyEvent'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorKeyReleaseEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.KeyEvent.KeyEvent ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorKeyReleaseEventCallback`.
foreign import ccall "wrapper"
    mk_ActorKeyReleaseEventCallback :: C_ActorKeyReleaseEventCallback -> IO (FunPtr C_ActorKeyReleaseEventCallback)

wrap_ActorKeyReleaseEventCallback :: 
    GObject a => (a -> ActorKeyReleaseEventCallback) ->
    C_ActorKeyReleaseEventCallback
wrap_ActorKeyReleaseEventCallback :: forall a.
GObject a =>
(a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
wrap_ActorKeyReleaseEventCallback a -> ActorKeyPressEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr KeyEvent
event Ptr ()
_ = do
    KeyEvent
event' <- ((ManagedPtr KeyEvent -> KeyEvent) -> Ptr KeyEvent -> IO KeyEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr KeyEvent -> KeyEvent
Clutter.KeyEvent.KeyEvent) Ptr KeyEvent
event
    Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorKeyPressEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  KeyEvent
event'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [keyReleaseEvent](#signal:keyReleaseEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #keyReleaseEvent callback
-- @
-- 
-- 
onActorKeyReleaseEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyReleaseEventCallback) -> m SignalHandlerId
onActorKeyReleaseEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorKeyPressEventCallback) -> m SignalHandlerId
onActorKeyReleaseEvent a
obj (?self::a) => ActorKeyPressEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorKeyPressEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorKeyPressEventCallback
ActorKeyPressEventCallback
cb
    let wrapped' :: C_ActorKeyPressEventCallback
wrapped' = (a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
forall a.
GObject a =>
(a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
wrap_ActorKeyReleaseEventCallback a -> ActorKeyPressEventCallback
wrapped
    FunPtr C_ActorKeyPressEventCallback
wrapped'' <- C_ActorKeyPressEventCallback
-> IO (FunPtr C_ActorKeyPressEventCallback)
mk_ActorKeyReleaseEventCallback C_ActorKeyPressEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorKeyPressEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-release-event" FunPtr C_ActorKeyPressEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [keyReleaseEvent](#signal:keyReleaseEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorKeyReleaseEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorKeyReleaseEventCallback) -> m SignalHandlerId
afterActorKeyReleaseEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorKeyPressEventCallback) -> m SignalHandlerId
afterActorKeyReleaseEvent a
obj (?self::a) => ActorKeyPressEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorKeyPressEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorKeyPressEventCallback
ActorKeyPressEventCallback
cb
    let wrapped' :: C_ActorKeyPressEventCallback
wrapped' = (a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
forall a.
GObject a =>
(a -> ActorKeyPressEventCallback) -> C_ActorKeyPressEventCallback
wrap_ActorKeyReleaseEventCallback a -> ActorKeyPressEventCallback
wrapped
    FunPtr C_ActorKeyPressEventCallback
wrapped'' <- C_ActorKeyPressEventCallback
-> IO (FunPtr C_ActorKeyPressEventCallback)
mk_ActorKeyReleaseEventCallback C_ActorKeyPressEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorKeyPressEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"key-release-event" FunPtr C_ActorKeyPressEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorKeyReleaseEventSignalInfo
instance SignalInfo ActorKeyReleaseEventSignalInfo where
    type HaskellCallbackType ActorKeyReleaseEventSignalInfo = ActorKeyReleaseEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorKeyReleaseEventCallback cb
        cb'' <- mk_ActorKeyReleaseEventCallback cb'
        connectSignalFunPtr obj "key-release-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::key-release-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:keyReleaseEvent"})

#endif

-- signal Actor::leave-event
-- | The [leaveEvent](#g:signal:leaveEvent) signal is emitted when the pointer leaves the /@actor@/.
-- 
-- /Since: 0.6/
type ActorLeaveEventCallback =
    Clutter.CrossingEvent.CrossingEvent
    -- ^ /@event@/: a t'GI.Clutter.Structs.CrossingEvent.CrossingEvent'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorLeaveEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.CrossingEvent.CrossingEvent ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorLeaveEventCallback`.
foreign import ccall "wrapper"
    mk_ActorLeaveEventCallback :: C_ActorLeaveEventCallback -> IO (FunPtr C_ActorLeaveEventCallback)

wrap_ActorLeaveEventCallback :: 
    GObject a => (a -> ActorLeaveEventCallback) ->
    C_ActorLeaveEventCallback
wrap_ActorLeaveEventCallback :: forall a.
GObject a =>
(a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
wrap_ActorLeaveEventCallback a -> ActorEnterEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr CrossingEvent
event Ptr ()
_ = do
    CrossingEvent
event' <- ((ManagedPtr CrossingEvent -> CrossingEvent)
-> Ptr CrossingEvent -> IO CrossingEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CrossingEvent -> CrossingEvent
Clutter.CrossingEvent.CrossingEvent) Ptr CrossingEvent
event
    Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorEnterEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  CrossingEvent
event'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [leaveEvent](#signal:leaveEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #leaveEvent callback
-- @
-- 
-- 
onActorLeaveEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorLeaveEventCallback) -> m SignalHandlerId
onActorLeaveEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorEnterEventCallback) -> m SignalHandlerId
onActorLeaveEvent a
obj (?self::a) => ActorEnterEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorEnterEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorEnterEventCallback
ActorEnterEventCallback
cb
    let wrapped' :: C_ActorEnterEventCallback
wrapped' = (a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
forall a.
GObject a =>
(a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
wrap_ActorLeaveEventCallback a -> ActorEnterEventCallback
wrapped
    FunPtr C_ActorEnterEventCallback
wrapped'' <- C_ActorEnterEventCallback -> IO (FunPtr C_ActorEnterEventCallback)
mk_ActorLeaveEventCallback C_ActorEnterEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorEnterEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"leave-event" FunPtr C_ActorEnterEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [leaveEvent](#signal:leaveEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorLeaveEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorLeaveEventCallback) -> m SignalHandlerId
afterActorLeaveEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorEnterEventCallback) -> m SignalHandlerId
afterActorLeaveEvent a
obj (?self::a) => ActorEnterEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorEnterEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorEnterEventCallback
ActorEnterEventCallback
cb
    let wrapped' :: C_ActorEnterEventCallback
wrapped' = (a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
forall a.
GObject a =>
(a -> ActorEnterEventCallback) -> C_ActorEnterEventCallback
wrap_ActorLeaveEventCallback a -> ActorEnterEventCallback
wrapped
    FunPtr C_ActorEnterEventCallback
wrapped'' <- C_ActorEnterEventCallback -> IO (FunPtr C_ActorEnterEventCallback)
mk_ActorLeaveEventCallback C_ActorEnterEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorEnterEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"leave-event" FunPtr C_ActorEnterEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorLeaveEventSignalInfo
instance SignalInfo ActorLeaveEventSignalInfo where
    type HaskellCallbackType ActorLeaveEventSignalInfo = ActorLeaveEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorLeaveEventCallback cb
        cb'' <- mk_ActorLeaveEventCallback cb'
        connectSignalFunPtr obj "leave-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::leave-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:leaveEvent"})

#endif

-- signal Actor::motion-event
-- | The [motionEvent](#g:signal:motionEvent) signal is emitted each time the mouse pointer is
-- moved over /@actor@/.
-- 
-- /Since: 0.6/
type ActorMotionEventCallback =
    Clutter.MotionEvent.MotionEvent
    -- ^ /@event@/: a t'GI.Clutter.Structs.MotionEvent.MotionEvent'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorMotionEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.MotionEvent.MotionEvent ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorMotionEventCallback`.
foreign import ccall "wrapper"
    mk_ActorMotionEventCallback :: C_ActorMotionEventCallback -> IO (FunPtr C_ActorMotionEventCallback)

wrap_ActorMotionEventCallback :: 
    GObject a => (a -> ActorMotionEventCallback) ->
    C_ActorMotionEventCallback
wrap_ActorMotionEventCallback :: forall a.
GObject a =>
(a -> ActorMotionEventCallback) -> C_ActorMotionEventCallback
wrap_ActorMotionEventCallback a -> ActorMotionEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr MotionEvent
event Ptr ()
_ = do
    MotionEvent
event' <- ((ManagedPtr MotionEvent -> MotionEvent)
-> Ptr MotionEvent -> IO MotionEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MotionEvent -> MotionEvent
Clutter.MotionEvent.MotionEvent) Ptr MotionEvent
event
    Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorMotionEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  MotionEvent
event'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [motionEvent](#signal:motionEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #motionEvent callback
-- @
-- 
-- 
onActorMotionEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorMotionEventCallback) -> m SignalHandlerId
onActorMotionEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorMotionEventCallback) -> m SignalHandlerId
onActorMotionEvent a
obj (?self::a) => ActorMotionEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorMotionEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorMotionEventCallback
ActorMotionEventCallback
cb
    let wrapped' :: C_ActorMotionEventCallback
wrapped' = (a -> ActorMotionEventCallback) -> C_ActorMotionEventCallback
forall a.
GObject a =>
(a -> ActorMotionEventCallback) -> C_ActorMotionEventCallback
wrap_ActorMotionEventCallback a -> ActorMotionEventCallback
wrapped
    FunPtr C_ActorMotionEventCallback
wrapped'' <- C_ActorMotionEventCallback
-> IO (FunPtr C_ActorMotionEventCallback)
mk_ActorMotionEventCallback C_ActorMotionEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorMotionEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"motion-event" FunPtr C_ActorMotionEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [motionEvent](#signal:motionEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorMotionEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorMotionEventCallback) -> m SignalHandlerId
afterActorMotionEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorMotionEventCallback) -> m SignalHandlerId
afterActorMotionEvent a
obj (?self::a) => ActorMotionEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorMotionEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorMotionEventCallback
ActorMotionEventCallback
cb
    let wrapped' :: C_ActorMotionEventCallback
wrapped' = (a -> ActorMotionEventCallback) -> C_ActorMotionEventCallback
forall a.
GObject a =>
(a -> ActorMotionEventCallback) -> C_ActorMotionEventCallback
wrap_ActorMotionEventCallback a -> ActorMotionEventCallback
wrapped
    FunPtr C_ActorMotionEventCallback
wrapped'' <- C_ActorMotionEventCallback
-> IO (FunPtr C_ActorMotionEventCallback)
mk_ActorMotionEventCallback C_ActorMotionEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorMotionEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"motion-event" FunPtr C_ActorMotionEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorMotionEventSignalInfo
instance SignalInfo ActorMotionEventSignalInfo where
    type HaskellCallbackType ActorMotionEventSignalInfo = ActorMotionEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorMotionEventCallback cb
        cb'' <- mk_ActorMotionEventCallback cb'
        connectSignalFunPtr obj "motion-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::motion-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:motionEvent"})

#endif

-- signal Actor::paint
{-# DEPRECATED ActorPaintCallback ["(Since version 1.12)","Override the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/paint/@ virtual","  function, use a t'GI.Clutter.Interfaces.Content.Content' implementation, or a t'GI.Clutter.Objects.Effect.Effect'","  instead of connecting to this signal."] #-}
-- | The [paint](#g:signal:paint) signal is emitted each time an actor is being painted.
-- 
-- Subclasses of t'GI.Clutter.Objects.Actor.Actor' should override the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/paint/@
-- virtual function paint themselves in that function.
-- 
-- It is strongly discouraged to connect a signal handler to
-- the [Actor::paint]("GI.Clutter.Objects.Actor#g:signal:paint") signal; if you want to change the paint
-- sequence of an existing t'GI.Clutter.Objects.Actor.Actor' instance, either create a new
-- t'GI.Clutter.Objects.Actor.Actor' class and override the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/paint/@ virtual
-- function, or use a t'GI.Clutter.Objects.Effect.Effect'. The [Actor::paint]("GI.Clutter.Objects.Actor#g:signal:paint") signal
-- will be removed in a future version of Clutter.
-- 
-- /Since: 0.8/
type ActorPaintCallback =
    IO ()

type C_ActorPaintCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorPaintCallback`.
foreign import ccall "wrapper"
    mk_ActorPaintCallback :: C_ActorPaintCallback -> IO (FunPtr C_ActorPaintCallback)

wrap_ActorPaintCallback :: 
    GObject a => (a -> ActorPaintCallback) ->
    C_ActorPaintCallback
wrap_ActorPaintCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorPaintCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [paint](#signal:paint) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #paint callback
-- @
-- 
-- 
onActorPaint :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorPaintCallback) -> m SignalHandlerId
onActorPaint :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorPaint a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorPaintCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorPaintCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"paint" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [paint](#signal:paint) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorPaint :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorPaintCallback) -> m SignalHandlerId
afterActorPaint :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorPaint a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorPaintCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorPaintCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"paint" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorPaintSignalInfo
instance SignalInfo ActorPaintSignalInfo where
    type HaskellCallbackType ActorPaintSignalInfo = ActorPaintCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorPaintCallback cb
        cb'' <- mk_ActorPaintCallback cb'
        connectSignalFunPtr obj "paint" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::paint"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:paint"})

#endif

-- signal Actor::parent-set
-- | This signal is emitted when the parent of the actor changes.
-- 
-- /Since: 0.2/
type ActorParentSetCallback =
    Maybe Actor
    -- ^ /@oldParent@/: the previous parent of the actor, or 'P.Nothing'
    -> IO ()

type C_ActorParentSetCallback =
    Ptr Actor ->                            -- object
    Ptr Actor ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorParentSetCallback`.
foreign import ccall "wrapper"
    mk_ActorParentSetCallback :: C_ActorParentSetCallback -> IO (FunPtr C_ActorParentSetCallback)

wrap_ActorParentSetCallback :: 
    GObject a => (a -> ActorParentSetCallback) ->
    C_ActorParentSetCallback
wrap_ActorParentSetCallback :: forall a.
GObject a =>
(a -> Maybe Actor -> IO ()) -> C_ActorParentSetCallback
wrap_ActorParentSetCallback a -> Maybe Actor -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr Actor
oldParent Ptr ()
_ = do
    Maybe Actor
maybeOldParent <-
        if Ptr Actor
oldParent Ptr Actor -> Ptr Actor -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Actor
forall a. Ptr a
nullPtr
        then Maybe Actor -> IO (Maybe Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Actor
forall a. Maybe a
Nothing
        else do
            Actor
oldParent' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
oldParent
            Maybe Actor -> IO (Maybe Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Actor -> IO (Maybe Actor))
-> Maybe Actor -> IO (Maybe Actor)
forall a b. (a -> b) -> a -> b
$ Actor -> Maybe Actor
forall a. a -> Maybe a
Just Actor
oldParent'
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> Maybe Actor -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  Maybe Actor
maybeOldParent


-- | Connect a signal handler for the [parentSet](#signal:parentSet) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #parentSet callback
-- @
-- 
-- 
onActorParentSet :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorParentSetCallback) -> m SignalHandlerId
onActorParentSet :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => Maybe Actor -> IO ()) -> m SignalHandlerId
onActorParentSet a
obj (?self::a) => Maybe Actor -> IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> Maybe Actor -> IO ()
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => Maybe Actor -> IO ()
Maybe Actor -> IO ()
cb
    let wrapped' :: C_ActorParentSetCallback
wrapped' = (a -> Maybe Actor -> IO ()) -> C_ActorParentSetCallback
forall a.
GObject a =>
(a -> Maybe Actor -> IO ()) -> C_ActorParentSetCallback
wrap_ActorParentSetCallback a -> Maybe Actor -> IO ()
wrapped
    FunPtr C_ActorParentSetCallback
wrapped'' <- C_ActorParentSetCallback -> IO (FunPtr C_ActorParentSetCallback)
mk_ActorParentSetCallback C_ActorParentSetCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorParentSetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"parent-set" FunPtr C_ActorParentSetCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [parentSet](#signal:parentSet) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorParentSet :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorParentSetCallback) -> m SignalHandlerId
afterActorParentSet :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => Maybe Actor -> IO ()) -> m SignalHandlerId
afterActorParentSet a
obj (?self::a) => Maybe Actor -> IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> Maybe Actor -> IO ()
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => Maybe Actor -> IO ()
Maybe Actor -> IO ()
cb
    let wrapped' :: C_ActorParentSetCallback
wrapped' = (a -> Maybe Actor -> IO ()) -> C_ActorParentSetCallback
forall a.
GObject a =>
(a -> Maybe Actor -> IO ()) -> C_ActorParentSetCallback
wrap_ActorParentSetCallback a -> Maybe Actor -> IO ()
wrapped
    FunPtr C_ActorParentSetCallback
wrapped'' <- C_ActorParentSetCallback -> IO (FunPtr C_ActorParentSetCallback)
mk_ActorParentSetCallback C_ActorParentSetCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorParentSetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"parent-set" FunPtr C_ActorParentSetCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorParentSetSignalInfo
instance SignalInfo ActorParentSetSignalInfo where
    type HaskellCallbackType ActorParentSetSignalInfo = ActorParentSetCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorParentSetCallback cb
        cb'' <- mk_ActorParentSetCallback cb'
        connectSignalFunPtr obj "parent-set" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::parent-set"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:parentSet"})

#endif

-- signal Actor::pick
{-# DEPRECATED ActorPickCallback ["(Since version 1.12)","Override the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/pick/@ virtual function","  instead."] #-}
-- | The [pick](#g:signal: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 'GI.Clutter.Objects.Stage.stageGetActorAtPos'.
-- The actor should paint its shape using the passed /@pickColor@/.
-- 
-- Subclasses of t'GI.Clutter.Objects.Actor.Actor' should override the class signal handler
-- and paint themselves in that function.
-- 
-- It is possible to connect a handler to the [pick](#g:signal:pick) signal in order
-- to set up some custom aspect of a paint in pick mode.
-- 
-- /Since: 1.0/
type ActorPickCallback =
    Clutter.Color.Color
    -- ^ /@color@/: the t'GI.Clutter.Structs.Color.Color' to be used when picking
    -> IO ()

type C_ActorPickCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.Color.Color ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorPickCallback`.
foreign import ccall "wrapper"
    mk_ActorPickCallback :: C_ActorPickCallback -> IO (FunPtr C_ActorPickCallback)

wrap_ActorPickCallback :: 
    GObject a => (a -> ActorPickCallback) ->
    C_ActorPickCallback
wrap_ActorPickCallback :: forall a.
GObject a =>
(a -> ActorPickCallback) -> C_ActorPickCallback
wrap_ActorPickCallback a -> ActorPickCallback
gi'cb Ptr Actor
gi'selfPtr Ptr Color
color Ptr ()
_ = do
    Ptr Color -> ActorPickCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Color
color (ActorPickCallback -> IO ()) -> ActorPickCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \Color
color' -> do
        Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorPickCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  Color
color'


-- | Connect a signal handler for the [pick](#signal:pick) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #pick callback
-- @
-- 
-- 
onActorPick :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorPickCallback) -> m SignalHandlerId
onActorPick :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorPickCallback) -> m SignalHandlerId
onActorPick a
obj (?self::a) => ActorPickCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorPickCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorPickCallback
ActorPickCallback
cb
    let wrapped' :: C_ActorPickCallback
wrapped' = (a -> ActorPickCallback) -> C_ActorPickCallback
forall a.
GObject a =>
(a -> ActorPickCallback) -> C_ActorPickCallback
wrap_ActorPickCallback a -> ActorPickCallback
wrapped
    FunPtr C_ActorPickCallback
wrapped'' <- C_ActorPickCallback -> IO (FunPtr C_ActorPickCallback)
mk_ActorPickCallback C_ActorPickCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorPickCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pick" FunPtr C_ActorPickCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pick](#signal:pick) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorPick :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorPickCallback) -> m SignalHandlerId
afterActorPick :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorPickCallback) -> m SignalHandlerId
afterActorPick a
obj (?self::a) => ActorPickCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorPickCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorPickCallback
ActorPickCallback
cb
    let wrapped' :: C_ActorPickCallback
wrapped' = (a -> ActorPickCallback) -> C_ActorPickCallback
forall a.
GObject a =>
(a -> ActorPickCallback) -> C_ActorPickCallback
wrap_ActorPickCallback a -> ActorPickCallback
wrapped
    FunPtr C_ActorPickCallback
wrapped'' <- C_ActorPickCallback -> IO (FunPtr C_ActorPickCallback)
mk_ActorPickCallback C_ActorPickCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorPickCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pick" FunPtr C_ActorPickCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorPickSignalInfo
instance SignalInfo ActorPickSignalInfo where
    type HaskellCallbackType ActorPickSignalInfo = ActorPickCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorPickCallback cb
        cb'' <- mk_ActorPickCallback cb'
        connectSignalFunPtr obj "pick" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::pick"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:pick"})

#endif

-- signal Actor::queue-redraw
-- | The [queue_redraw](#g:signal:queue_redraw) signal is emitted when 'GI.Clutter.Objects.Actor.actorQueueRedraw'
-- is called on /@origin@/.
-- 
-- The default implementation for t'GI.Clutter.Objects.Actor.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 t'GI.Clutter.Objects.Stage.Stage' queues a 'GI.Clutter.Objects.Stage.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 t'GI.Clutter.Objects.Stage.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 'GI.Clutter.Objects.Stage.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 'GI.Clutter.Functions.threadsAddRepaintFunc'
-- or 'GI.Clutter.Functions.threadsAddRepaintFuncFull'.
-- 
-- /Since: 1.0/
type ActorQueueRedrawCallback =
    Actor
    -- ^ /@origin@/: the actor which initiated the redraw request
    -> IO ()

type C_ActorQueueRedrawCallback =
    Ptr Actor ->                            -- object
    Ptr Actor ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorQueueRedrawCallback`.
foreign import ccall "wrapper"
    mk_ActorQueueRedrawCallback :: C_ActorQueueRedrawCallback -> IO (FunPtr C_ActorQueueRedrawCallback)

wrap_ActorQueueRedrawCallback :: 
    GObject a => (a -> ActorQueueRedrawCallback) ->
    C_ActorQueueRedrawCallback
wrap_ActorQueueRedrawCallback :: forall a.
GObject a =>
(a -> Actor -> IO ()) -> C_ActorParentSetCallback
wrap_ActorQueueRedrawCallback a -> Actor -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr Actor
origin Ptr ()
_ = do
    Actor
origin' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
origin
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> Actor -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  Actor
origin'


-- | Connect a signal handler for the [queueRedraw](#signal:queueRedraw) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #queueRedraw callback
-- @
-- 
-- 
onActorQueueRedraw :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorQueueRedrawCallback) -> m SignalHandlerId
onActorQueueRedraw :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => Actor -> IO ()) -> m SignalHandlerId
onActorQueueRedraw a
obj (?self::a) => Actor -> IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> Actor -> IO ()
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => Actor -> IO ()
Actor -> IO ()
cb
    let wrapped' :: C_ActorParentSetCallback
wrapped' = (a -> Actor -> IO ()) -> C_ActorParentSetCallback
forall a.
GObject a =>
(a -> Actor -> IO ()) -> C_ActorParentSetCallback
wrap_ActorQueueRedrawCallback a -> Actor -> IO ()
wrapped
    FunPtr C_ActorParentSetCallback
wrapped'' <- C_ActorParentSetCallback -> IO (FunPtr C_ActorParentSetCallback)
mk_ActorQueueRedrawCallback C_ActorParentSetCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorParentSetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"queue-redraw" FunPtr C_ActorParentSetCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [queueRedraw](#signal:queueRedraw) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorQueueRedraw :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorQueueRedrawCallback) -> m SignalHandlerId
afterActorQueueRedraw :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => Actor -> IO ()) -> m SignalHandlerId
afterActorQueueRedraw a
obj (?self::a) => Actor -> IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> Actor -> IO ()
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => Actor -> IO ()
Actor -> IO ()
cb
    let wrapped' :: C_ActorParentSetCallback
wrapped' = (a -> Actor -> IO ()) -> C_ActorParentSetCallback
forall a.
GObject a =>
(a -> Actor -> IO ()) -> C_ActorParentSetCallback
wrap_ActorQueueRedrawCallback a -> Actor -> IO ()
wrapped
    FunPtr C_ActorParentSetCallback
wrapped'' <- C_ActorParentSetCallback -> IO (FunPtr C_ActorParentSetCallback)
mk_ActorQueueRedrawCallback C_ActorParentSetCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorParentSetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"queue-redraw" FunPtr C_ActorParentSetCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorQueueRedrawSignalInfo
instance SignalInfo ActorQueueRedrawSignalInfo where
    type HaskellCallbackType ActorQueueRedrawSignalInfo = ActorQueueRedrawCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorQueueRedrawCallback cb
        cb'' <- mk_ActorQueueRedrawCallback cb'
        connectSignalFunPtr obj "queue-redraw" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::queue-redraw"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:queueRedraw"})

#endif

-- signal Actor::queue-relayout
-- | The [queue_layout](#g:signal:queue_layout) signal is emitted when 'GI.Clutter.Objects.Actor.actorQueueRelayout'
-- is called on an actor.
-- 
-- The default implementation for t'GI.Clutter.Objects.Actor.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 t'GI.Clutter.Objects.Clone.Clone' actors. Applications will
-- not normally need to connect to this signal.
-- 
-- /Since: 1.2/
type ActorQueueRelayoutCallback =
    IO ()

type C_ActorQueueRelayoutCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorQueueRelayoutCallback`.
foreign import ccall "wrapper"
    mk_ActorQueueRelayoutCallback :: C_ActorQueueRelayoutCallback -> IO (FunPtr C_ActorQueueRelayoutCallback)

wrap_ActorQueueRelayoutCallback :: 
    GObject a => (a -> ActorQueueRelayoutCallback) ->
    C_ActorQueueRelayoutCallback
wrap_ActorQueueRelayoutCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorQueueRelayoutCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [queueRelayout](#signal:queueRelayout) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #queueRelayout callback
-- @
-- 
-- 
onActorQueueRelayout :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorQueueRelayoutCallback) -> m SignalHandlerId
onActorQueueRelayout :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorQueueRelayout a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorQueueRelayoutCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorQueueRelayoutCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"queue-relayout" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [queueRelayout](#signal:queueRelayout) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorQueueRelayout :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorQueueRelayoutCallback) -> m SignalHandlerId
afterActorQueueRelayout :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorQueueRelayout a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorQueueRelayoutCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorQueueRelayoutCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"queue-relayout" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorQueueRelayoutSignalInfo
instance SignalInfo ActorQueueRelayoutSignalInfo where
    type HaskellCallbackType ActorQueueRelayoutSignalInfo = ActorQueueRelayoutCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorQueueRelayoutCallback cb
        cb'' <- mk_ActorQueueRelayoutCallback cb'
        connectSignalFunPtr obj "queue-relayout" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::queue-relayout"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:queueRelayout"})

#endif

-- signal Actor::realize
{-# DEPRECATED ActorRealizeCallback ["(Since version 1.16)","The signal should not be used in newly","  written code"] #-}
-- | The [realize](#g:signal:realize) signal is emitted each time an actor is being
-- realized.
-- 
-- /Since: 0.8/
type ActorRealizeCallback =
    IO ()

type C_ActorRealizeCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorRealizeCallback`.
foreign import ccall "wrapper"
    mk_ActorRealizeCallback :: C_ActorRealizeCallback -> IO (FunPtr C_ActorRealizeCallback)

wrap_ActorRealizeCallback :: 
    GObject a => (a -> ActorRealizeCallback) ->
    C_ActorRealizeCallback
wrap_ActorRealizeCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorRealizeCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [realize](#signal:realize) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #realize callback
-- @
-- 
-- 
onActorRealize :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorRealizeCallback) -> m SignalHandlerId
onActorRealize :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorRealize a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorRealizeCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorRealizeCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"realize" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [realize](#signal:realize) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorRealize :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorRealizeCallback) -> m SignalHandlerId
afterActorRealize :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorRealize a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorRealizeCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorRealizeCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"realize" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorRealizeSignalInfo
instance SignalInfo ActorRealizeSignalInfo where
    type HaskellCallbackType ActorRealizeSignalInfo = ActorRealizeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorRealizeCallback cb
        cb'' <- mk_ActorRealizeCallback cb'
        connectSignalFunPtr obj "realize" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::realize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:realize"})

#endif

-- signal Actor::scroll-event
-- | The [scrollEvent](#g:signal:scrollEvent) signal is emitted each time the mouse is
-- scrolled on /@actor@/
-- 
-- /Since: 0.6/
type ActorScrollEventCallback =
    Clutter.ScrollEvent.ScrollEvent
    -- ^ /@event@/: a t'GI.Clutter.Structs.ScrollEvent.ScrollEvent'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the event has been handled by the actor,
    --   or 'P.False' to continue the emission.

type C_ActorScrollEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.ScrollEvent.ScrollEvent ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorScrollEventCallback`.
foreign import ccall "wrapper"
    mk_ActorScrollEventCallback :: C_ActorScrollEventCallback -> IO (FunPtr C_ActorScrollEventCallback)

wrap_ActorScrollEventCallback :: 
    GObject a => (a -> ActorScrollEventCallback) ->
    C_ActorScrollEventCallback
wrap_ActorScrollEventCallback :: forall a.
GObject a =>
(a -> ActorScrollEventCallback) -> C_ActorScrollEventCallback
wrap_ActorScrollEventCallback a -> ActorScrollEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr ScrollEvent
event Ptr ()
_ = do
    ScrollEvent
event' <- ((ManagedPtr ScrollEvent -> ScrollEvent)
-> Ptr ScrollEvent -> IO ScrollEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ScrollEvent -> ScrollEvent
Clutter.ScrollEvent.ScrollEvent) Ptr ScrollEvent
event
    Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorScrollEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  ScrollEvent
event'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [scrollEvent](#signal:scrollEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #scrollEvent callback
-- @
-- 
-- 
onActorScrollEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorScrollEventCallback) -> m SignalHandlerId
onActorScrollEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorScrollEventCallback) -> m SignalHandlerId
onActorScrollEvent a
obj (?self::a) => ActorScrollEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorScrollEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorScrollEventCallback
ActorScrollEventCallback
cb
    let wrapped' :: C_ActorScrollEventCallback
wrapped' = (a -> ActorScrollEventCallback) -> C_ActorScrollEventCallback
forall a.
GObject a =>
(a -> ActorScrollEventCallback) -> C_ActorScrollEventCallback
wrap_ActorScrollEventCallback a -> ActorScrollEventCallback
wrapped
    FunPtr C_ActorScrollEventCallback
wrapped'' <- C_ActorScrollEventCallback
-> IO (FunPtr C_ActorScrollEventCallback)
mk_ActorScrollEventCallback C_ActorScrollEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorScrollEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"scroll-event" FunPtr C_ActorScrollEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [scrollEvent](#signal:scrollEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorScrollEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorScrollEventCallback) -> m SignalHandlerId
afterActorScrollEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => ActorScrollEventCallback) -> m SignalHandlerId
afterActorScrollEvent a
obj (?self::a) => ActorScrollEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorScrollEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorScrollEventCallback
ActorScrollEventCallback
cb
    let wrapped' :: C_ActorScrollEventCallback
wrapped' = (a -> ActorScrollEventCallback) -> C_ActorScrollEventCallback
forall a.
GObject a =>
(a -> ActorScrollEventCallback) -> C_ActorScrollEventCallback
wrap_ActorScrollEventCallback a -> ActorScrollEventCallback
wrapped
    FunPtr C_ActorScrollEventCallback
wrapped'' <- C_ActorScrollEventCallback
-> IO (FunPtr C_ActorScrollEventCallback)
mk_ActorScrollEventCallback C_ActorScrollEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorScrollEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"scroll-event" FunPtr C_ActorScrollEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorScrollEventSignalInfo
instance SignalInfo ActorScrollEventSignalInfo where
    type HaskellCallbackType ActorScrollEventSignalInfo = ActorScrollEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorScrollEventCallback cb
        cb'' <- mk_ActorScrollEventCallback cb'
        connectSignalFunPtr obj "scroll-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::scroll-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:scrollEvent"})

#endif

-- signal Actor::show
-- | The [show](#g:signal:show) signal is emitted when an actor is visible and
-- rendered on the stage.
-- 
-- /Since: 0.2/
type ActorShowCallback =
    IO ()

type C_ActorShowCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorShowCallback`.
foreign import ccall "wrapper"
    mk_ActorShowCallback :: C_ActorShowCallback -> IO (FunPtr C_ActorShowCallback)

wrap_ActorShowCallback :: 
    GObject a => (a -> ActorShowCallback) ->
    C_ActorShowCallback
wrap_ActorShowCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorShowCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [show](#signal:show) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #show callback
-- @
-- 
-- 
onActorShow :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorShowCallback) -> m SignalHandlerId
onActorShow :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorShow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorShowCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorShowCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [show](#signal:show) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorShow :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorShowCallback) -> m SignalHandlerId
afterActorShow :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorShow a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorShowCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorShowCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorShowSignalInfo
instance SignalInfo ActorShowSignalInfo where
    type HaskellCallbackType ActorShowSignalInfo = ActorShowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorShowCallback cb
        cb'' <- mk_ActorShowCallback cb'
        connectSignalFunPtr obj "show" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::show"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:show"})

#endif

-- signal Actor::touch-event
-- | The [touchEvent](#g:signal:touchEvent) signal is emitted each time a touch
-- begin\/end\/update\/cancel event.
-- 
-- /Since: 1.12/
type ActorTouchEventCallback =
    Clutter.Event.Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> IO Bool
    -- ^ __Returns:__ 'GI.Clutter.Constants.EVENT_STOP' if the event has been handled by
    --   the actor, or 'GI.Clutter.Constants.EVENT_PROPAGATE' to continue the emission.

type C_ActorTouchEventCallback =
    Ptr Actor ->                            -- object
    Ptr Clutter.Event.Event ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ActorTouchEventCallback`.
foreign import ccall "wrapper"
    mk_ActorTouchEventCallback :: C_ActorTouchEventCallback -> IO (FunPtr C_ActorTouchEventCallback)

wrap_ActorTouchEventCallback :: 
    GObject a => (a -> ActorTouchEventCallback) ->
    C_ActorTouchEventCallback
wrap_ActorTouchEventCallback :: forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorTouchEventCallback a -> ActorCapturedEventCallback
gi'cb Ptr Actor
gi'selfPtr Ptr Event
event Ptr ()
_ = do
    Ptr Event -> (Event -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Event
event ((Event -> IO CInt) -> IO CInt) -> (Event -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \Event
event' -> do
        Bool
result <- Ptr Actor -> (Actor -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO Bool) -> IO Bool) -> (Actor -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorCapturedEventCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  Event
event'
        let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
        CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [touchEvent](#signal:touchEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #touchEvent callback
-- @
-- 
-- 
onActorTouchEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorTouchEventCallback) -> m SignalHandlerId
onActorTouchEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorCapturedEventCallback) -> m SignalHandlerId
onActorTouchEvent a
obj (?self::a) => ActorCapturedEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorCapturedEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorCapturedEventCallback
ActorCapturedEventCallback
cb
    let wrapped' :: C_ActorCapturedEventCallback
wrapped' = (a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorTouchEventCallback a -> ActorCapturedEventCallback
wrapped
    FunPtr C_ActorCapturedEventCallback
wrapped'' <- C_ActorCapturedEventCallback
-> IO (FunPtr C_ActorCapturedEventCallback)
mk_ActorTouchEventCallback C_ActorCapturedEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorCapturedEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"touch-event" FunPtr C_ActorCapturedEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [touchEvent](#signal:touchEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorTouchEvent :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorTouchEventCallback) -> m SignalHandlerId
afterActorTouchEvent :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> ((?self::a) => ActorCapturedEventCallback) -> m SignalHandlerId
afterActorTouchEvent a
obj (?self::a) => ActorCapturedEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorCapturedEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorCapturedEventCallback
ActorCapturedEventCallback
cb
    let wrapped' :: C_ActorCapturedEventCallback
wrapped' = (a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
forall a.
GObject a =>
(a -> ActorCapturedEventCallback) -> C_ActorCapturedEventCallback
wrap_ActorTouchEventCallback a -> ActorCapturedEventCallback
wrapped
    FunPtr C_ActorCapturedEventCallback
wrapped'' <- C_ActorCapturedEventCallback
-> IO (FunPtr C_ActorCapturedEventCallback)
mk_ActorTouchEventCallback C_ActorCapturedEventCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorCapturedEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"touch-event" FunPtr C_ActorCapturedEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorTouchEventSignalInfo
instance SignalInfo ActorTouchEventSignalInfo where
    type HaskellCallbackType ActorTouchEventSignalInfo = ActorTouchEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorTouchEventCallback cb
        cb'' <- mk_ActorTouchEventCallback cb'
        connectSignalFunPtr obj "touch-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::touch-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:touchEvent"})

#endif

-- signal Actor::transition-stopped
-- | The [transitionStopped](#g:signal: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 'GI.Clutter.Objects.Timeline.timelineStop', or it has been removed from the
-- transitions applied on /@actor@/, using 'GI.Clutter.Objects.Actor.actorRemoveTransition'.
-- 
-- /Since: 1.12/
type ActorTransitionStoppedCallback =
    T.Text
    -- ^ /@name@/: the name of the transition
    -> Bool
    -- ^ /@isFinished@/: whether the transition was finished, or stopped
    -> IO ()

type C_ActorTransitionStoppedCallback =
    Ptr Actor ->                            -- object
    CString ->
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorTransitionStoppedCallback`.
foreign import ccall "wrapper"
    mk_ActorTransitionStoppedCallback :: C_ActorTransitionStoppedCallback -> IO (FunPtr C_ActorTransitionStoppedCallback)

wrap_ActorTransitionStoppedCallback :: 
    GObject a => (a -> ActorTransitionStoppedCallback) ->
    C_ActorTransitionStoppedCallback
wrap_ActorTransitionStoppedCallback :: forall a.
GObject a =>
(a -> ActorTransitionStoppedCallback)
-> C_ActorTransitionStoppedCallback
wrap_ActorTransitionStoppedCallback a -> ActorTransitionStoppedCallback
gi'cb Ptr Actor
gi'selfPtr CString
name CInt
isFinished Ptr ()
_ = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    let isFinished' :: Bool
isFinished' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
isFinished
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> ActorTransitionStoppedCallback
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self)  Text
name' Bool
isFinished'


-- | Connect a signal handler for the [transitionStopped](#signal:transitionStopped) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #transitionStopped callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@transition-stopped::detail@” instead.
-- 
onActorTransitionStopped :: (IsActor a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ActorTransitionStoppedCallback) -> m SignalHandlerId
onActorTransitionStopped :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => ActorTransitionStoppedCallback)
-> m SignalHandlerId
onActorTransitionStopped a
obj Maybe Text
detail (?self::a) => ActorTransitionStoppedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorTransitionStoppedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorTransitionStoppedCallback
ActorTransitionStoppedCallback
cb
    let wrapped' :: C_ActorTransitionStoppedCallback
wrapped' = (a -> ActorTransitionStoppedCallback)
-> C_ActorTransitionStoppedCallback
forall a.
GObject a =>
(a -> ActorTransitionStoppedCallback)
-> C_ActorTransitionStoppedCallback
wrap_ActorTransitionStoppedCallback a -> ActorTransitionStoppedCallback
wrapped
    FunPtr C_ActorTransitionStoppedCallback
wrapped'' <- C_ActorTransitionStoppedCallback
-> IO (FunPtr C_ActorTransitionStoppedCallback)
mk_ActorTransitionStoppedCallback C_ActorTransitionStoppedCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorTransitionStoppedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"transition-stopped" FunPtr C_ActorTransitionStoppedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
detail

-- | Connect a signal handler for the [transitionStopped](#signal:transitionStopped) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorTransitionStopped :: (IsActor a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ActorTransitionStoppedCallback) -> m SignalHandlerId
afterActorTransitionStopped :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => ActorTransitionStoppedCallback)
-> m SignalHandlerId
afterActorTransitionStopped a
obj Maybe Text
detail (?self::a) => ActorTransitionStoppedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ActorTransitionStoppedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ActorTransitionStoppedCallback
ActorTransitionStoppedCallback
cb
    let wrapped' :: C_ActorTransitionStoppedCallback
wrapped' = (a -> ActorTransitionStoppedCallback)
-> C_ActorTransitionStoppedCallback
forall a.
GObject a =>
(a -> ActorTransitionStoppedCallback)
-> C_ActorTransitionStoppedCallback
wrap_ActorTransitionStoppedCallback a -> ActorTransitionStoppedCallback
wrapped
    FunPtr C_ActorTransitionStoppedCallback
wrapped'' <- C_ActorTransitionStoppedCallback
-> IO (FunPtr C_ActorTransitionStoppedCallback)
mk_ActorTransitionStoppedCallback C_ActorTransitionStoppedCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorTransitionStoppedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"transition-stopped" FunPtr C_ActorTransitionStoppedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
detail


#if defined(ENABLE_OVERLOADING)
data ActorTransitionStoppedSignalInfo
instance SignalInfo ActorTransitionStoppedSignalInfo where
    type HaskellCallbackType ActorTransitionStoppedSignalInfo = ActorTransitionStoppedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorTransitionStoppedCallback cb
        cb'' <- mk_ActorTransitionStoppedCallback cb'
        connectSignalFunPtr obj "transition-stopped" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::transition-stopped"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:transitionStopped"})

#endif

-- signal Actor::transitions-completed
-- | The [transitionsCompleted](#g:signal:transitionsCompleted) signal is emitted once all transitions
-- involving /@actor@/ are complete.
-- 
-- /Since: 1.10/
type ActorTransitionsCompletedCallback =
    IO ()

type C_ActorTransitionsCompletedCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorTransitionsCompletedCallback`.
foreign import ccall "wrapper"
    mk_ActorTransitionsCompletedCallback :: C_ActorTransitionsCompletedCallback -> IO (FunPtr C_ActorTransitionsCompletedCallback)

wrap_ActorTransitionsCompletedCallback :: 
    GObject a => (a -> ActorTransitionsCompletedCallback) ->
    C_ActorTransitionsCompletedCallback
wrap_ActorTransitionsCompletedCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorTransitionsCompletedCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [transitionsCompleted](#signal:transitionsCompleted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #transitionsCompleted callback
-- @
-- 
-- 
onActorTransitionsCompleted :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorTransitionsCompletedCallback) -> m SignalHandlerId
onActorTransitionsCompleted :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorTransitionsCompleted a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorTransitionsCompletedCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorTransitionsCompletedCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"transitions-completed" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [transitionsCompleted](#signal:transitionsCompleted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorTransitionsCompleted :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorTransitionsCompletedCallback) -> m SignalHandlerId
afterActorTransitionsCompleted :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorTransitionsCompleted a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorTransitionsCompletedCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorTransitionsCompletedCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"transitions-completed" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorTransitionsCompletedSignalInfo
instance SignalInfo ActorTransitionsCompletedSignalInfo where
    type HaskellCallbackType ActorTransitionsCompletedSignalInfo = ActorTransitionsCompletedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorTransitionsCompletedCallback cb
        cb'' <- mk_ActorTransitionsCompletedCallback cb'
        connectSignalFunPtr obj "transitions-completed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::transitions-completed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:transitionsCompleted"})

#endif

-- signal Actor::unrealize
{-# DEPRECATED ActorUnrealizeCallback ["(Since version 1.16)","The signal should not be used in newly","  written code"] #-}
-- | The [unrealize](#g:signal:unrealize) signal is emitted each time an actor is being
-- unrealized.
-- 
-- /Since: 0.8/
type ActorUnrealizeCallback =
    IO ()

type C_ActorUnrealizeCallback =
    Ptr Actor ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ActorUnrealizeCallback`.
foreign import ccall "wrapper"
    mk_ActorUnrealizeCallback :: C_ActorUnrealizeCallback -> IO (FunPtr C_ActorUnrealizeCallback)

wrap_ActorUnrealizeCallback :: 
    GObject a => (a -> ActorUnrealizeCallback) ->
    C_ActorUnrealizeCallback
wrap_ActorUnrealizeCallback :: forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorUnrealizeCallback a -> IO ()
gi'cb Ptr Actor
gi'selfPtr Ptr ()
_ = do
    Ptr Actor -> (Actor -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Actor
gi'selfPtr ((Actor -> IO ()) -> IO ()) -> (Actor -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Actor
gi'self -> a -> IO ()
gi'cb (Actor -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Actor
gi'self) 


-- | Connect a signal handler for the [unrealize](#signal:unrealize) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' actor #unrealize callback
-- @
-- 
-- 
onActorUnrealize :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorUnrealizeCallback) -> m SignalHandlerId
onActorUnrealize :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActorUnrealize a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorUnrealizeCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorUnrealizeCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unrealize" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [unrealize](#signal:unrealize) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.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.
-- 
afterActorUnrealize :: (IsActor a, MonadIO m) => a -> ((?self :: a) => ActorUnrealizeCallback) -> m SignalHandlerId
afterActorUnrealize :: forall a (m :: * -> *).
(IsActor a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActorUnrealize a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ActorDestroyCallback
wrapped' = (a -> IO ()) -> C_ActorDestroyCallback
forall a. GObject a => (a -> IO ()) -> C_ActorDestroyCallback
wrap_ActorUnrealizeCallback a -> IO ()
wrapped
    FunPtr C_ActorDestroyCallback
wrapped'' <- C_ActorDestroyCallback -> IO (FunPtr C_ActorDestroyCallback)
mk_ActorUnrealizeCallback C_ActorDestroyCallback
wrapped'
    a
-> Text
-> FunPtr C_ActorDestroyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unrealize" FunPtr C_ActorDestroyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActorUnrealizeSignalInfo
instance SignalInfo ActorUnrealizeSignalInfo where
    type HaskellCallbackType ActorUnrealizeSignalInfo = ActorUnrealizeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActorUnrealizeCallback cb
        cb'' <- mk_ActorUnrealizeCallback cb'
        connectSignalFunPtr obj "unrealize" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor::unrealize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:signal:unrealize"})

#endif

-- VVV Prop "actions"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Action"})
   -- Flags: [PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Set the value of the “@actions@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #actions 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorActions :: (MonadIO m, IsActor o, Clutter.Action.IsAction a) => o -> a -> m ()
setActorActions :: forall (m :: * -> *) o a.
(MonadIO m, IsActor o, IsAction a) =>
o -> a -> m ()
setActorActions o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"actions" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@actions@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorActions :: (IsActor o, MIO.MonadIO m, Clutter.Action.IsAction a) => a -> m (GValueConstruct o)
constructActorActions :: forall o (m :: * -> *) a.
(IsActor o, MonadIO m, IsAction a) =>
a -> m (GValueConstruct o)
constructActorActions a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"actions" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@actions@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #actions
-- @
clearActorActions :: (MonadIO m, IsActor o) => o -> m ()
clearActorActions :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorActions o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Action -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"actions" (Maybe Action
forall a. Maybe a
Nothing :: Maybe Clutter.Action.Action)

#if defined(ENABLE_OVERLOADING)
data ActorActionsPropertyInfo
instance AttrInfo ActorActionsPropertyInfo where
    type AttrAllowedOps ActorActionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear]
    type AttrBaseTypeConstraint ActorActionsPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorActionsPropertyInfo = Clutter.Action.IsAction
    type AttrTransferTypeConstraint ActorActionsPropertyInfo = Clutter.Action.IsAction
    type AttrTransferType ActorActionsPropertyInfo = Clutter.Action.Action
    type AttrGetType ActorActionsPropertyInfo = ()
    type AttrLabel ActorActionsPropertyInfo = "actions"
    type AttrOrigin ActorActionsPropertyInfo = Actor
    attrGet = undefined
    attrSet = setActorActions
    attrTransfer _ v = do
        unsafeCastTo Clutter.Action.Action v
    attrConstruct = constructActorActions
    attrClear = clearActorActions
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actions"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:actions"
        })
#endif

-- VVV Prop "allocation"
   -- Type: TInterface (Name {namespace = "Clutter", name = "ActorBox"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@allocation@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #allocation
-- @
getActorAllocation :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.ActorBox.ActorBox)
getActorAllocation :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe ActorBox)
getActorAllocation o
obj = IO (Maybe ActorBox) -> m (Maybe ActorBox)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe ActorBox) -> m (Maybe ActorBox))
-> IO (Maybe ActorBox) -> m (Maybe ActorBox)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr ActorBox -> ActorBox)
-> IO (Maybe ActorBox)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"allocation" ManagedPtr ActorBox -> ActorBox
Clutter.ActorBox.ActorBox

#if defined(ENABLE_OVERLOADING)
data ActorAllocationPropertyInfo
instance AttrInfo ActorAllocationPropertyInfo where
    type AttrAllowedOps ActorAllocationPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorAllocationPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorAllocationPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorAllocationPropertyInfo = (~) ()
    type AttrTransferType ActorAllocationPropertyInfo = ()
    type AttrGetType ActorAllocationPropertyInfo = (Maybe Clutter.ActorBox.ActorBox)
    type AttrLabel ActorAllocationPropertyInfo = "allocation"
    type AttrOrigin ActorAllocationPropertyInfo = Actor
    attrGet = getActorAllocation
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.allocation"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:allocation"
        })
#endif

-- VVV Prop "anchor-gravity"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Gravity"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@anchor-gravity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #anchorGravity
-- @
getActorAnchorGravity :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.Gravity
getActorAnchorGravity :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Gravity
getActorAnchorGravity o
obj = IO Gravity -> m Gravity
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Gravity -> m Gravity) -> IO Gravity -> m Gravity
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Gravity
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"anchor-gravity"

-- | Set the value of the “@anchor-gravity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #anchorGravity 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorAnchorGravity :: (MonadIO m, IsActor o) => o -> Clutter.Enums.Gravity -> m ()
setActorAnchorGravity :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Gravity -> m ()
setActorAnchorGravity o
obj Gravity
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Gravity -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"anchor-gravity" Gravity
val

-- | Construct a `GValueConstruct` with valid value for the “@anchor-gravity@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorAnchorGravity :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.Gravity -> m (GValueConstruct o)
constructActorAnchorGravity :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Gravity -> m (GValueConstruct o)
constructActorAnchorGravity Gravity
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Gravity -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"anchor-gravity" Gravity
val

#if defined(ENABLE_OVERLOADING)
data ActorAnchorGravityPropertyInfo
instance AttrInfo ActorAnchorGravityPropertyInfo where
    type AttrAllowedOps ActorAnchorGravityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorAnchorGravityPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorAnchorGravityPropertyInfo = (~) Clutter.Enums.Gravity
    type AttrTransferTypeConstraint ActorAnchorGravityPropertyInfo = (~) Clutter.Enums.Gravity
    type AttrTransferType ActorAnchorGravityPropertyInfo = Clutter.Enums.Gravity
    type AttrGetType ActorAnchorGravityPropertyInfo = Clutter.Enums.Gravity
    type AttrLabel ActorAnchorGravityPropertyInfo = "anchor-gravity"
    type AttrOrigin ActorAnchorGravityPropertyInfo = Actor
    attrGet = getActorAnchorGravity
    attrSet = setActorAnchorGravity
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorAnchorGravity
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.anchorGravity"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:anchorGravity"
        })
#endif

-- VVV Prop "anchor-x"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@anchor-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #anchorX
-- @
getActorAnchorX :: (MonadIO m, IsActor o) => o -> m Float
getActorAnchorX :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorAnchorX o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"anchor-x"

-- | Set the value of the “@anchor-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #anchorX 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorAnchorX :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorAnchorX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorAnchorX o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"anchor-x" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@anchor-x@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorAnchorX :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorAnchorX :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorAnchorX Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"anchor-x" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorAnchorXPropertyInfo
instance AttrInfo ActorAnchorXPropertyInfo where
    type AttrAllowedOps ActorAnchorXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorAnchorXPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorAnchorXPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorAnchorXPropertyInfo = (~) Float
    type AttrTransferType ActorAnchorXPropertyInfo = Float
    type AttrGetType ActorAnchorXPropertyInfo = Float
    type AttrLabel ActorAnchorXPropertyInfo = "anchor-x"
    type AttrOrigin ActorAnchorXPropertyInfo = Actor
    attrGet = getActorAnchorX
    attrSet = setActorAnchorX
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorAnchorX
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.anchorX"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:anchorX"
        })
#endif

-- VVV Prop "anchor-y"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@anchor-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #anchorY
-- @
getActorAnchorY :: (MonadIO m, IsActor o) => o -> m Float
getActorAnchorY :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorAnchorY o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"anchor-y"

-- | Set the value of the “@anchor-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #anchorY 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorAnchorY :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorAnchorY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorAnchorY o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"anchor-y" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@anchor-y@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorAnchorY :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorAnchorY :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorAnchorY Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"anchor-y" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorAnchorYPropertyInfo
instance AttrInfo ActorAnchorYPropertyInfo where
    type AttrAllowedOps ActorAnchorYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorAnchorYPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorAnchorYPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorAnchorYPropertyInfo = (~) Float
    type AttrTransferType ActorAnchorYPropertyInfo = Float
    type AttrGetType ActorAnchorYPropertyInfo = Float
    type AttrLabel ActorAnchorYPropertyInfo = "anchor-y"
    type AttrOrigin ActorAnchorYPropertyInfo = Actor
    attrGet = getActorAnchorY
    attrSet = setActorAnchorY
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorAnchorY
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.anchorY"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:anchorY"
        })
#endif

-- VVV Prop "background-color"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Color"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@background-color@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #backgroundColor
-- @
getActorBackgroundColor :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Color.Color)
getActorBackgroundColor :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Color)
getActorBackgroundColor o
obj = IO (Maybe Color) -> m (Maybe Color)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Color) -> m (Maybe Color))
-> IO (Maybe Color) -> m (Maybe Color)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Color -> Color) -> IO (Maybe Color)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"background-color" ManagedPtr Color -> Color
Clutter.Color.Color

-- | Set the value of the “@background-color@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #backgroundColor 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorBackgroundColor :: (MonadIO m, IsActor o) => o -> Clutter.Color.Color -> m ()
setActorBackgroundColor :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Color -> m ()
setActorBackgroundColor o
obj Color
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Color -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"background-color" (Color -> Maybe Color
forall a. a -> Maybe a
Just Color
val)

-- | Construct a `GValueConstruct` with valid value for the “@background-color@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorBackgroundColor :: (IsActor o, MIO.MonadIO m) => Clutter.Color.Color -> m (GValueConstruct o)
constructActorBackgroundColor :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Color -> m (GValueConstruct o)
constructActorBackgroundColor Color
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Color -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"background-color" (Color -> Maybe Color
forall a. a -> Maybe a
P.Just Color
val)

-- | Set the value of the “@background-color@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #backgroundColor
-- @
clearActorBackgroundColor :: (MonadIO m, IsActor o) => o -> m ()
clearActorBackgroundColor :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorBackgroundColor o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Color -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"background-color" (Maybe Color
forall a. Maybe a
Nothing :: Maybe Clutter.Color.Color)

#if defined(ENABLE_OVERLOADING)
data ActorBackgroundColorPropertyInfo
instance AttrInfo ActorBackgroundColorPropertyInfo where
    type AttrAllowedOps ActorBackgroundColorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorBackgroundColorPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorBackgroundColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferTypeConstraint ActorBackgroundColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferType ActorBackgroundColorPropertyInfo = Clutter.Color.Color
    type AttrGetType ActorBackgroundColorPropertyInfo = (Maybe Clutter.Color.Color)
    type AttrLabel ActorBackgroundColorPropertyInfo = "background-color"
    type AttrOrigin ActorBackgroundColorPropertyInfo = Actor
    attrGet = getActorBackgroundColor
    attrSet = setActorBackgroundColor
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorBackgroundColor
    attrClear = clearActorBackgroundColor
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.backgroundColor"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:backgroundColor"
        })
#endif

-- VVV Prop "background-color-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@background-color-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #backgroundColorSet
-- @
getActorBackgroundColorSet :: (MonadIO m, IsActor o) => o -> m Bool
getActorBackgroundColorSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorBackgroundColorSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"background-color-set"

#if defined(ENABLE_OVERLOADING)
data ActorBackgroundColorSetPropertyInfo
instance AttrInfo ActorBackgroundColorSetPropertyInfo where
    type AttrAllowedOps ActorBackgroundColorSetPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ActorBackgroundColorSetPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorBackgroundColorSetPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorBackgroundColorSetPropertyInfo = (~) ()
    type AttrTransferType ActorBackgroundColorSetPropertyInfo = ()
    type AttrGetType ActorBackgroundColorSetPropertyInfo = Bool
    type AttrLabel ActorBackgroundColorSetPropertyInfo = "background-color-set"
    type AttrOrigin ActorBackgroundColorSetPropertyInfo = Actor
    attrGet = getActorBackgroundColorSet
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.backgroundColorSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:backgroundColorSet"
        })
#endif

-- VVV Prop "child-transform"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Matrix"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@child-transform@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #childTransform
-- @
getActorChildTransform :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Matrix.Matrix)
getActorChildTransform :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Matrix)
getActorChildTransform o
obj = IO (Maybe Matrix) -> m (Maybe Matrix)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Matrix) -> m (Maybe Matrix))
-> IO (Maybe Matrix) -> m (Maybe Matrix)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Matrix -> Matrix) -> IO (Maybe Matrix)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"child-transform" ManagedPtr Matrix -> Matrix
Clutter.Matrix.Matrix

-- | Set the value of the “@child-transform@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #childTransform 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorChildTransform :: (MonadIO m, IsActor o) => o -> Clutter.Matrix.Matrix -> m ()
setActorChildTransform :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Matrix -> m ()
setActorChildTransform o
obj Matrix
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Matrix -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"child-transform" (Matrix -> Maybe Matrix
forall a. a -> Maybe a
Just Matrix
val)

-- | Construct a `GValueConstruct` with valid value for the “@child-transform@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorChildTransform :: (IsActor o, MIO.MonadIO m) => Clutter.Matrix.Matrix -> m (GValueConstruct o)
constructActorChildTransform :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Matrix -> m (GValueConstruct o)
constructActorChildTransform Matrix
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Matrix -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"child-transform" (Matrix -> Maybe Matrix
forall a. a -> Maybe a
P.Just Matrix
val)

-- | Set the value of the “@child-transform@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #childTransform
-- @
clearActorChildTransform :: (MonadIO m, IsActor o) => o -> m ()
clearActorChildTransform :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorChildTransform o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Matrix -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"child-transform" (Maybe Matrix
forall a. Maybe a
Nothing :: Maybe Clutter.Matrix.Matrix)

#if defined(ENABLE_OVERLOADING)
data ActorChildTransformPropertyInfo
instance AttrInfo ActorChildTransformPropertyInfo where
    type AttrAllowedOps ActorChildTransformPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorChildTransformPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorChildTransformPropertyInfo = (~) Clutter.Matrix.Matrix
    type AttrTransferTypeConstraint ActorChildTransformPropertyInfo = (~) Clutter.Matrix.Matrix
    type AttrTransferType ActorChildTransformPropertyInfo = Clutter.Matrix.Matrix
    type AttrGetType ActorChildTransformPropertyInfo = (Maybe Clutter.Matrix.Matrix)
    type AttrLabel ActorChildTransformPropertyInfo = "child-transform"
    type AttrOrigin ActorChildTransformPropertyInfo = Actor
    attrGet = getActorChildTransform
    attrSet = setActorChildTransform
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorChildTransform
    attrClear = clearActorChildTransform
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.childTransform"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:childTransform"
        })
#endif

-- VVV Prop "child-transform-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@child-transform-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #childTransformSet
-- @
getActorChildTransformSet :: (MonadIO m, IsActor o) => o -> m Bool
getActorChildTransformSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorChildTransformSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"child-transform-set"

#if defined(ENABLE_OVERLOADING)
data ActorChildTransformSetPropertyInfo
instance AttrInfo ActorChildTransformSetPropertyInfo where
    type AttrAllowedOps ActorChildTransformSetPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ActorChildTransformSetPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorChildTransformSetPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorChildTransformSetPropertyInfo = (~) ()
    type AttrTransferType ActorChildTransformSetPropertyInfo = ()
    type AttrGetType ActorChildTransformSetPropertyInfo = Bool
    type AttrLabel ActorChildTransformSetPropertyInfo = "child-transform-set"
    type AttrOrigin ActorChildTransformSetPropertyInfo = Actor
    attrGet = getActorChildTransformSet
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.childTransformSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:childTransformSet"
        })
#endif

-- VVV Prop "clip"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Geometry"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@clip@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #clip
-- @
getActorClip :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Geometry.Geometry)
getActorClip :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Geometry)
getActorClip o
obj = IO (Maybe Geometry) -> m (Maybe Geometry)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Geometry) -> m (Maybe Geometry))
-> IO (Maybe Geometry) -> m (Maybe Geometry)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr Geometry -> Geometry)
-> IO (Maybe Geometry)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"clip" ManagedPtr Geometry -> Geometry
Clutter.Geometry.Geometry

-- | Set the value of the “@clip@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #clip 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorClip :: (MonadIO m, IsActor o) => o -> Clutter.Geometry.Geometry -> m ()
setActorClip :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Geometry -> m ()
setActorClip o
obj Geometry
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Geometry -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"clip" (Geometry -> Maybe Geometry
forall a. a -> Maybe a
Just Geometry
val)

-- | Construct a `GValueConstruct` with valid value for the “@clip@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorClip :: (IsActor o, MIO.MonadIO m) => Clutter.Geometry.Geometry -> m (GValueConstruct o)
constructActorClip :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Geometry -> m (GValueConstruct o)
constructActorClip Geometry
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Geometry -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"clip" (Geometry -> Maybe Geometry
forall a. a -> Maybe a
P.Just Geometry
val)

-- | Set the value of the “@clip@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #clip
-- @
clearActorClip :: (MonadIO m, IsActor o) => o -> m ()
clearActorClip :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorClip o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Geometry -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"clip" (Maybe Geometry
forall a. Maybe a
Nothing :: Maybe Clutter.Geometry.Geometry)

#if defined(ENABLE_OVERLOADING)
data ActorClipPropertyInfo
instance AttrInfo ActorClipPropertyInfo where
    type AttrAllowedOps ActorClipPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorClipPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorClipPropertyInfo = (~) Clutter.Geometry.Geometry
    type AttrTransferTypeConstraint ActorClipPropertyInfo = (~) Clutter.Geometry.Geometry
    type AttrTransferType ActorClipPropertyInfo = Clutter.Geometry.Geometry
    type AttrGetType ActorClipPropertyInfo = (Maybe Clutter.Geometry.Geometry)
    type AttrLabel ActorClipPropertyInfo = "clip"
    type AttrOrigin ActorClipPropertyInfo = Actor
    attrGet = getActorClip
    attrSet = setActorClip
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorClip
    attrClear = clearActorClip
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.clip"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:clip"
        })
#endif

-- VVV Prop "clip-rect"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Rect"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@clip-rect@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #clipRect
-- @
getActorClipRect :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Rect.Rect)
getActorClipRect :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Rect)
getActorClipRect o
obj = IO (Maybe Rect) -> m (Maybe Rect)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Rect) -> m (Maybe Rect))
-> IO (Maybe Rect) -> m (Maybe Rect)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Rect -> Rect) -> IO (Maybe Rect)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"clip-rect" ManagedPtr Rect -> Rect
Clutter.Rect.Rect

-- | Set the value of the “@clip-rect@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #clipRect 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorClipRect :: (MonadIO m, IsActor o) => o -> Clutter.Rect.Rect -> m ()
setActorClipRect :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Rect -> m ()
setActorClipRect o
obj Rect
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Rect -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"clip-rect" (Rect -> Maybe Rect
forall a. a -> Maybe a
Just Rect
val)

-- | Construct a `GValueConstruct` with valid value for the “@clip-rect@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorClipRect :: (IsActor o, MIO.MonadIO m) => Clutter.Rect.Rect -> m (GValueConstruct o)
constructActorClipRect :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Rect -> m (GValueConstruct o)
constructActorClipRect Rect
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Rect -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"clip-rect" (Rect -> Maybe Rect
forall a. a -> Maybe a
P.Just Rect
val)

-- | Set the value of the “@clip-rect@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #clipRect
-- @
clearActorClipRect :: (MonadIO m, IsActor o) => o -> m ()
clearActorClipRect :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorClipRect o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Rect -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"clip-rect" (Maybe Rect
forall a. Maybe a
Nothing :: Maybe Clutter.Rect.Rect)

#if defined(ENABLE_OVERLOADING)
data ActorClipRectPropertyInfo
instance AttrInfo ActorClipRectPropertyInfo where
    type AttrAllowedOps ActorClipRectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorClipRectPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorClipRectPropertyInfo = (~) Clutter.Rect.Rect
    type AttrTransferTypeConstraint ActorClipRectPropertyInfo = (~) Clutter.Rect.Rect
    type AttrTransferType ActorClipRectPropertyInfo = Clutter.Rect.Rect
    type AttrGetType ActorClipRectPropertyInfo = (Maybe Clutter.Rect.Rect)
    type AttrLabel ActorClipRectPropertyInfo = "clip-rect"
    type AttrOrigin ActorClipRectPropertyInfo = Actor
    attrGet = getActorClipRect
    attrSet = setActorClipRect
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorClipRect
    attrClear = clearActorClipRect
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.clipRect"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:clipRect"
        })
#endif

-- VVV Prop "clip-to-allocation"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@clip-to-allocation@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #clipToAllocation
-- @
getActorClipToAllocation :: (MonadIO m, IsActor o) => o -> m Bool
getActorClipToAllocation :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorClipToAllocation o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"clip-to-allocation"

-- | Set the value of the “@clip-to-allocation@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #clipToAllocation 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorClipToAllocation :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorClipToAllocation :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorClipToAllocation o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"clip-to-allocation" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@clip-to-allocation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorClipToAllocation :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorClipToAllocation :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorClipToAllocation Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"clip-to-allocation" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorClipToAllocationPropertyInfo
instance AttrInfo ActorClipToAllocationPropertyInfo where
    type AttrAllowedOps ActorClipToAllocationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorClipToAllocationPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorClipToAllocationPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorClipToAllocationPropertyInfo = (~) Bool
    type AttrTransferType ActorClipToAllocationPropertyInfo = Bool
    type AttrGetType ActorClipToAllocationPropertyInfo = Bool
    type AttrLabel ActorClipToAllocationPropertyInfo = "clip-to-allocation"
    type AttrOrigin ActorClipToAllocationPropertyInfo = Actor
    attrGet = getActorClipToAllocation
    attrSet = setActorClipToAllocation
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorClipToAllocation
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.clipToAllocation"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:clipToAllocation"
        })
#endif

-- VVV Prop "constraints"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Constraint"})
   -- Flags: [PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Set the value of the “@constraints@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #constraints 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorConstraints :: (MonadIO m, IsActor o, Clutter.Constraint.IsConstraint a) => o -> a -> m ()
setActorConstraints :: forall (m :: * -> *) o a.
(MonadIO m, IsActor o, IsConstraint a) =>
o -> a -> m ()
setActorConstraints o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"constraints" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@constraints@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorConstraints :: (IsActor o, MIO.MonadIO m, Clutter.Constraint.IsConstraint a) => a -> m (GValueConstruct o)
constructActorConstraints :: forall o (m :: * -> *) a.
(IsActor o, MonadIO m, IsConstraint a) =>
a -> m (GValueConstruct o)
constructActorConstraints a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"constraints" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@constraints@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #constraints
-- @
clearActorConstraints :: (MonadIO m, IsActor o) => o -> m ()
clearActorConstraints :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorConstraints o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Constraint -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"constraints" (Maybe Constraint
forall a. Maybe a
Nothing :: Maybe Clutter.Constraint.Constraint)

#if defined(ENABLE_OVERLOADING)
data ActorConstraintsPropertyInfo
instance AttrInfo ActorConstraintsPropertyInfo where
    type AttrAllowedOps ActorConstraintsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear]
    type AttrBaseTypeConstraint ActorConstraintsPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorConstraintsPropertyInfo = Clutter.Constraint.IsConstraint
    type AttrTransferTypeConstraint ActorConstraintsPropertyInfo = Clutter.Constraint.IsConstraint
    type AttrTransferType ActorConstraintsPropertyInfo = Clutter.Constraint.Constraint
    type AttrGetType ActorConstraintsPropertyInfo = ()
    type AttrLabel ActorConstraintsPropertyInfo = "constraints"
    type AttrOrigin ActorConstraintsPropertyInfo = Actor
    attrGet = undefined
    attrSet = setActorConstraints
    attrTransfer _ v = do
        unsafeCastTo Clutter.Constraint.Constraint v
    attrConstruct = constructActorConstraints
    attrClear = clearActorConstraints
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.constraints"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:constraints"
        })
#endif

-- VVV Prop "content"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Content"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

-- | Get the value of the “@content@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #content
-- @
getActorContent :: (MonadIO m, IsActor o) => o -> m Clutter.Content.Content
getActorContent :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Content
getActorContent o
obj = IO Content -> m Content
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Content -> m Content) -> IO Content -> m Content
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Content) -> IO Content
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getActorContent" (IO (Maybe Content) -> IO Content)
-> IO (Maybe Content) -> IO Content
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Content -> Content) -> IO (Maybe Content)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"content" ManagedPtr Content -> Content
Clutter.Content.Content

-- | Set the value of the “@content@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #content 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorContent :: (MonadIO m, IsActor o, Clutter.Content.IsContent a) => o -> a -> m ()
setActorContent :: forall (m :: * -> *) o a.
(MonadIO m, IsActor o, IsContent a) =>
o -> a -> m ()
setActorContent o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"content" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@content@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorContent :: (IsActor o, MIO.MonadIO m, Clutter.Content.IsContent a) => a -> m (GValueConstruct o)
constructActorContent :: forall o (m :: * -> *) a.
(IsActor o, MonadIO m, IsContent a) =>
a -> m (GValueConstruct o)
constructActorContent a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"content" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@content@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #content
-- @
clearActorContent :: (MonadIO m, IsActor o) => o -> m ()
clearActorContent :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorContent o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Content -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"content" (Maybe Content
forall a. Maybe a
Nothing :: Maybe Clutter.Content.Content)

#if defined(ENABLE_OVERLOADING)
data ActorContentPropertyInfo
instance AttrInfo ActorContentPropertyInfo where
    type AttrAllowedOps ActorContentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorContentPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorContentPropertyInfo = Clutter.Content.IsContent
    type AttrTransferTypeConstraint ActorContentPropertyInfo = Clutter.Content.IsContent
    type AttrTransferType ActorContentPropertyInfo = Clutter.Content.Content
    type AttrGetType ActorContentPropertyInfo = Clutter.Content.Content
    type AttrLabel ActorContentPropertyInfo = "content"
    type AttrOrigin ActorContentPropertyInfo = Actor
    attrGet = getActorContent
    attrSet = setActorContent
    attrTransfer _ v = do
        unsafeCastTo Clutter.Content.Content v
    attrConstruct = constructActorContent
    attrClear = clearActorContent
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.content"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:content"
        })
#endif

-- VVV Prop "content-box"
   -- Type: TInterface (Name {namespace = "Clutter", name = "ActorBox"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@content-box@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #contentBox
-- @
getActorContentBox :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.ActorBox.ActorBox)
getActorContentBox :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe ActorBox)
getActorContentBox o
obj = IO (Maybe ActorBox) -> m (Maybe ActorBox)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe ActorBox) -> m (Maybe ActorBox))
-> IO (Maybe ActorBox) -> m (Maybe ActorBox)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr ActorBox -> ActorBox)
-> IO (Maybe ActorBox)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"content-box" ManagedPtr ActorBox -> ActorBox
Clutter.ActorBox.ActorBox

#if defined(ENABLE_OVERLOADING)
data ActorContentBoxPropertyInfo
instance AttrInfo ActorContentBoxPropertyInfo where
    type AttrAllowedOps ActorContentBoxPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorContentBoxPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorContentBoxPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorContentBoxPropertyInfo = (~) ()
    type AttrTransferType ActorContentBoxPropertyInfo = ()
    type AttrGetType ActorContentBoxPropertyInfo = (Maybe Clutter.ActorBox.ActorBox)
    type AttrLabel ActorContentBoxPropertyInfo = "content-box"
    type AttrOrigin ActorContentBoxPropertyInfo = Actor
    attrGet = getActorContentBox
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.contentBox"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:contentBox"
        })
#endif

-- VVV Prop "content-gravity"
   -- Type: TInterface (Name {namespace = "Clutter", name = "ContentGravity"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@content-gravity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #contentGravity
-- @
getActorContentGravity :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.ContentGravity
getActorContentGravity :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m ContentGravity
getActorContentGravity o
obj = IO ContentGravity -> m ContentGravity
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ContentGravity -> m ContentGravity)
-> IO ContentGravity -> m ContentGravity
forall a b. (a -> b) -> a -> b
$ o -> String -> IO ContentGravity
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"content-gravity"

-- | Set the value of the “@content-gravity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #contentGravity 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorContentGravity :: (MonadIO m, IsActor o) => o -> Clutter.Enums.ContentGravity -> m ()
setActorContentGravity :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> ContentGravity -> m ()
setActorContentGravity o
obj ContentGravity
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ContentGravity -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"content-gravity" ContentGravity
val

-- | Construct a `GValueConstruct` with valid value for the “@content-gravity@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorContentGravity :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.ContentGravity -> m (GValueConstruct o)
constructActorContentGravity :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
ContentGravity -> m (GValueConstruct o)
constructActorContentGravity ContentGravity
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> ContentGravity -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"content-gravity" ContentGravity
val

#if defined(ENABLE_OVERLOADING)
data ActorContentGravityPropertyInfo
instance AttrInfo ActorContentGravityPropertyInfo where
    type AttrAllowedOps ActorContentGravityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorContentGravityPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorContentGravityPropertyInfo = (~) Clutter.Enums.ContentGravity
    type AttrTransferTypeConstraint ActorContentGravityPropertyInfo = (~) Clutter.Enums.ContentGravity
    type AttrTransferType ActorContentGravityPropertyInfo = Clutter.Enums.ContentGravity
    type AttrGetType ActorContentGravityPropertyInfo = Clutter.Enums.ContentGravity
    type AttrLabel ActorContentGravityPropertyInfo = "content-gravity"
    type AttrOrigin ActorContentGravityPropertyInfo = Actor
    attrGet = getActorContentGravity
    attrSet = setActorContentGravity
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorContentGravity
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.contentGravity"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:contentGravity"
        })
#endif

-- VVV Prop "content-repeat"
   -- Type: TInterface (Name {namespace = "Clutter", name = "ContentRepeat"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@content-repeat@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #contentRepeat
-- @
getActorContentRepeat :: (MonadIO m, IsActor o) => o -> m [Clutter.Flags.ContentRepeat]
getActorContentRepeat :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m [ContentRepeat]
getActorContentRepeat o
obj = IO [ContentRepeat] -> m [ContentRepeat]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [ContentRepeat] -> m [ContentRepeat])
-> IO [ContentRepeat] -> m [ContentRepeat]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [ContentRepeat]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"content-repeat"

-- | Set the value of the “@content-repeat@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #contentRepeat 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorContentRepeat :: (MonadIO m, IsActor o) => o -> [Clutter.Flags.ContentRepeat] -> m ()
setActorContentRepeat :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> [ContentRepeat] -> m ()
setActorContentRepeat o
obj [ContentRepeat]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> [ContentRepeat] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"content-repeat" [ContentRepeat]
val

-- | Construct a `GValueConstruct` with valid value for the “@content-repeat@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorContentRepeat :: (IsActor o, MIO.MonadIO m) => [Clutter.Flags.ContentRepeat] -> m (GValueConstruct o)
constructActorContentRepeat :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
[ContentRepeat] -> m (GValueConstruct o)
constructActorContentRepeat [ContentRepeat]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [ContentRepeat] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"content-repeat" [ContentRepeat]
val

#if defined(ENABLE_OVERLOADING)
data ActorContentRepeatPropertyInfo
instance AttrInfo ActorContentRepeatPropertyInfo where
    type AttrAllowedOps ActorContentRepeatPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorContentRepeatPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorContentRepeatPropertyInfo = (~) [Clutter.Flags.ContentRepeat]
    type AttrTransferTypeConstraint ActorContentRepeatPropertyInfo = (~) [Clutter.Flags.ContentRepeat]
    type AttrTransferType ActorContentRepeatPropertyInfo = [Clutter.Flags.ContentRepeat]
    type AttrGetType ActorContentRepeatPropertyInfo = [Clutter.Flags.ContentRepeat]
    type AttrLabel ActorContentRepeatPropertyInfo = "content-repeat"
    type AttrOrigin ActorContentRepeatPropertyInfo = Actor
    attrGet = getActorContentRepeat
    attrSet = setActorContentRepeat
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorContentRepeat
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.contentRepeat"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:contentRepeat"
        })
#endif

-- VVV Prop "depth"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@depth@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #depth
-- @
getActorDepth :: (MonadIO m, IsActor o) => o -> m Float
getActorDepth :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorDepth o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"depth"

-- | Set the value of the “@depth@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #depth 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorDepth :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorDepth :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorDepth o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"depth" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@depth@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorDepth :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorDepth :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorDepth Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"depth" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorDepthPropertyInfo
instance AttrInfo ActorDepthPropertyInfo where
    type AttrAllowedOps ActorDepthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorDepthPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorDepthPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorDepthPropertyInfo = (~) Float
    type AttrTransferType ActorDepthPropertyInfo = Float
    type AttrGetType ActorDepthPropertyInfo = Float
    type AttrLabel ActorDepthPropertyInfo = "depth"
    type AttrOrigin ActorDepthPropertyInfo = Actor
    attrGet = getActorDepth
    attrSet = setActorDepth
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorDepth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.depth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:depth"
        })
#endif

-- VVV Prop "effect"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Effect"})
   -- Flags: [PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Set the value of the “@effect@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #effect 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorEffect :: (MonadIO m, IsActor o, Clutter.Effect.IsEffect a) => o -> a -> m ()
setActorEffect :: forall (m :: * -> *) o a.
(MonadIO m, IsActor o, IsEffect a) =>
o -> a -> m ()
setActorEffect o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"effect" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@effect@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorEffect :: (IsActor o, MIO.MonadIO m, Clutter.Effect.IsEffect a) => a -> m (GValueConstruct o)
constructActorEffect :: forall o (m :: * -> *) a.
(IsActor o, MonadIO m, IsEffect a) =>
a -> m (GValueConstruct o)
constructActorEffect a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"effect" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@effect@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #effect
-- @
clearActorEffect :: (MonadIO m, IsActor o) => o -> m ()
clearActorEffect :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorEffect o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Effect -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"effect" (Maybe Effect
forall a. Maybe a
Nothing :: Maybe Clutter.Effect.Effect)

#if defined(ENABLE_OVERLOADING)
data ActorEffectPropertyInfo
instance AttrInfo ActorEffectPropertyInfo where
    type AttrAllowedOps ActorEffectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear]
    type AttrBaseTypeConstraint ActorEffectPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorEffectPropertyInfo = Clutter.Effect.IsEffect
    type AttrTransferTypeConstraint ActorEffectPropertyInfo = Clutter.Effect.IsEffect
    type AttrTransferType ActorEffectPropertyInfo = Clutter.Effect.Effect
    type AttrGetType ActorEffectPropertyInfo = ()
    type AttrLabel ActorEffectPropertyInfo = "effect"
    type AttrOrigin ActorEffectPropertyInfo = Actor
    attrGet = undefined
    attrSet = setActorEffect
    attrTransfer _ v = do
        unsafeCastTo Clutter.Effect.Effect v
    attrConstruct = constructActorEffect
    attrClear = clearActorEffect
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.effect"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:effect"
        })
#endif

-- VVV Prop "first-child"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Actor"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@first-child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #firstChild
-- @
getActorFirstChild :: (MonadIO m, IsActor o) => o -> m Actor
getActorFirstChild :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Actor
getActorFirstChild o
obj = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Actor) -> IO Actor
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getActorFirstChild" (IO (Maybe Actor) -> IO Actor) -> IO (Maybe Actor) -> IO Actor
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Actor -> Actor) -> IO (Maybe Actor)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"first-child" ManagedPtr Actor -> Actor
Actor

#if defined(ENABLE_OVERLOADING)
data ActorFirstChildPropertyInfo
instance AttrInfo ActorFirstChildPropertyInfo where
    type AttrAllowedOps ActorFirstChildPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorFirstChildPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorFirstChildPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorFirstChildPropertyInfo = (~) ()
    type AttrTransferType ActorFirstChildPropertyInfo = ()
    type AttrGetType ActorFirstChildPropertyInfo = Actor
    type AttrLabel ActorFirstChildPropertyInfo = "first-child"
    type AttrOrigin ActorFirstChildPropertyInfo = Actor
    attrGet = getActorFirstChild
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.firstChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:firstChild"
        })
#endif

-- VVV Prop "fixed-position-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@fixed-position-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #fixedPositionSet
-- @
getActorFixedPositionSet :: (MonadIO m, IsActor o) => o -> m Bool
getActorFixedPositionSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorFixedPositionSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"fixed-position-set"

-- | Set the value of the “@fixed-position-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #fixedPositionSet 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorFixedPositionSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorFixedPositionSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorFixedPositionSet o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"fixed-position-set" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@fixed-position-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorFixedPositionSet :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorFixedPositionSet :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorFixedPositionSet Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"fixed-position-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorFixedPositionSetPropertyInfo
instance AttrInfo ActorFixedPositionSetPropertyInfo where
    type AttrAllowedOps ActorFixedPositionSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorFixedPositionSetPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorFixedPositionSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorFixedPositionSetPropertyInfo = (~) Bool
    type AttrTransferType ActorFixedPositionSetPropertyInfo = Bool
    type AttrGetType ActorFixedPositionSetPropertyInfo = Bool
    type AttrLabel ActorFixedPositionSetPropertyInfo = "fixed-position-set"
    type AttrOrigin ActorFixedPositionSetPropertyInfo = Actor
    attrGet = getActorFixedPositionSet
    attrSet = setActorFixedPositionSet
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorFixedPositionSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.fixedPositionSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:fixedPositionSet"
        })
#endif

-- VVV Prop "fixed-x"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@fixed-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #fixedX
-- @
getActorFixedX :: (MonadIO m, IsActor o) => o -> m Float
getActorFixedX :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorFixedX o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"fixed-x"

-- | Set the value of the “@fixed-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #fixedX 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorFixedX :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorFixedX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorFixedX o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"fixed-x" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@fixed-x@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorFixedX :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorFixedX :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorFixedX Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"fixed-x" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorFixedXPropertyInfo
instance AttrInfo ActorFixedXPropertyInfo where
    type AttrAllowedOps ActorFixedXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorFixedXPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorFixedXPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorFixedXPropertyInfo = (~) Float
    type AttrTransferType ActorFixedXPropertyInfo = Float
    type AttrGetType ActorFixedXPropertyInfo = Float
    type AttrLabel ActorFixedXPropertyInfo = "fixed-x"
    type AttrOrigin ActorFixedXPropertyInfo = Actor
    attrGet = getActorFixedX
    attrSet = setActorFixedX
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorFixedX
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.fixedX"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:fixedX"
        })
#endif

-- VVV Prop "fixed-y"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@fixed-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #fixedY
-- @
getActorFixedY :: (MonadIO m, IsActor o) => o -> m Float
getActorFixedY :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorFixedY o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"fixed-y"

-- | Set the value of the “@fixed-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #fixedY 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorFixedY :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorFixedY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorFixedY o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"fixed-y" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@fixed-y@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorFixedY :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorFixedY :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorFixedY Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"fixed-y" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorFixedYPropertyInfo
instance AttrInfo ActorFixedYPropertyInfo where
    type AttrAllowedOps ActorFixedYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorFixedYPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorFixedYPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorFixedYPropertyInfo = (~) Float
    type AttrTransferType ActorFixedYPropertyInfo = Float
    type AttrGetType ActorFixedYPropertyInfo = Float
    type AttrLabel ActorFixedYPropertyInfo = "fixed-y"
    type AttrOrigin ActorFixedYPropertyInfo = Actor
    attrGet = getActorFixedY
    attrSet = setActorFixedY
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorFixedY
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.fixedY"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:fixedY"
        })
#endif

-- VVV Prop "has-clip"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@has-clip@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #hasClip
-- @
getActorHasClip :: (MonadIO m, IsActor o) => o -> m Bool
getActorHasClip :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorHasClip o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"has-clip"

#if defined(ENABLE_OVERLOADING)
data ActorHasClipPropertyInfo
instance AttrInfo ActorHasClipPropertyInfo where
    type AttrAllowedOps ActorHasClipPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ActorHasClipPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorHasClipPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorHasClipPropertyInfo = (~) ()
    type AttrTransferType ActorHasClipPropertyInfo = ()
    type AttrGetType ActorHasClipPropertyInfo = Bool
    type AttrLabel ActorHasClipPropertyInfo = "has-clip"
    type AttrOrigin ActorHasClipPropertyInfo = Actor
    attrGet = getActorHasClip
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.hasClip"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:hasClip"
        })
#endif

-- VVV Prop "has-pointer"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@has-pointer@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #hasPointer
-- @
getActorHasPointer :: (MonadIO m, IsActor o) => o -> m Bool
getActorHasPointer :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorHasPointer o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"has-pointer"

#if defined(ENABLE_OVERLOADING)
data ActorHasPointerPropertyInfo
instance AttrInfo ActorHasPointerPropertyInfo where
    type AttrAllowedOps ActorHasPointerPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ActorHasPointerPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorHasPointerPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorHasPointerPropertyInfo = (~) ()
    type AttrTransferType ActorHasPointerPropertyInfo = ()
    type AttrGetType ActorHasPointerPropertyInfo = Bool
    type AttrLabel ActorHasPointerPropertyInfo = "has-pointer"
    type AttrOrigin ActorHasPointerPropertyInfo = Actor
    attrGet = getActorHasPointer
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.hasPointer"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:hasPointer"
        })
#endif

-- VVV Prop "height"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #height
-- @
getActorHeight :: (MonadIO m, IsActor o) => o -> m Float
getActorHeight :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorHeight o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"height"

-- | Set the value of the “@height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #height 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorHeight :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorHeight :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorHeight o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"height" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorHeight :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorHeight :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorHeight Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"height" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorHeightPropertyInfo
instance AttrInfo ActorHeightPropertyInfo where
    type AttrAllowedOps ActorHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorHeightPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorHeightPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorHeightPropertyInfo = (~) Float
    type AttrTransferType ActorHeightPropertyInfo = Float
    type AttrGetType ActorHeightPropertyInfo = Float
    type AttrLabel ActorHeightPropertyInfo = "height"
    type AttrOrigin ActorHeightPropertyInfo = Actor
    attrGet = getActorHeight
    attrSet = setActorHeight
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorHeight
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.height"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:height"
        })
#endif

-- VVV Prop "last-child"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Actor"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@last-child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #lastChild
-- @
getActorLastChild :: (MonadIO m, IsActor o) => o -> m Actor
getActorLastChild :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Actor
getActorLastChild o
obj = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Actor) -> IO Actor
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getActorLastChild" (IO (Maybe Actor) -> IO Actor) -> IO (Maybe Actor) -> IO Actor
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Actor -> Actor) -> IO (Maybe Actor)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"last-child" ManagedPtr Actor -> Actor
Actor

#if defined(ENABLE_OVERLOADING)
data ActorLastChildPropertyInfo
instance AttrInfo ActorLastChildPropertyInfo where
    type AttrAllowedOps ActorLastChildPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorLastChildPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorLastChildPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorLastChildPropertyInfo = (~) ()
    type AttrTransferType ActorLastChildPropertyInfo = ()
    type AttrGetType ActorLastChildPropertyInfo = Actor
    type AttrLabel ActorLastChildPropertyInfo = "last-child"
    type AttrOrigin ActorLastChildPropertyInfo = Actor
    attrGet = getActorLastChild
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.lastChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:lastChild"
        })
#endif

-- VVV Prop "layout-manager"
   -- Type: TInterface (Name {namespace = "Clutter", name = "LayoutManager"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

-- | Get the value of the “@layout-manager@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #layoutManager
-- @
getActorLayoutManager :: (MonadIO m, IsActor o) => o -> m Clutter.LayoutManager.LayoutManager
getActorLayoutManager :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m LayoutManager
getActorLayoutManager o
obj = IO LayoutManager -> m LayoutManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO LayoutManager -> m LayoutManager)
-> IO LayoutManager -> m LayoutManager
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe LayoutManager) -> IO LayoutManager
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getActorLayoutManager" (IO (Maybe LayoutManager) -> IO LayoutManager)
-> IO (Maybe LayoutManager) -> IO LayoutManager
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr LayoutManager -> LayoutManager)
-> IO (Maybe LayoutManager)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"layout-manager" ManagedPtr LayoutManager -> LayoutManager
Clutter.LayoutManager.LayoutManager

-- | Set the value of the “@layout-manager@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #layoutManager 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorLayoutManager :: (MonadIO m, IsActor o, Clutter.LayoutManager.IsLayoutManager a) => o -> a -> m ()
setActorLayoutManager :: forall (m :: * -> *) o a.
(MonadIO m, IsActor o, IsLayoutManager a) =>
o -> a -> m ()
setActorLayoutManager o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"layout-manager" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@layout-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorLayoutManager :: (IsActor o, MIO.MonadIO m, Clutter.LayoutManager.IsLayoutManager a) => a -> m (GValueConstruct o)
constructActorLayoutManager :: forall o (m :: * -> *) a.
(IsActor o, MonadIO m, IsLayoutManager a) =>
a -> m (GValueConstruct o)
constructActorLayoutManager a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"layout-manager" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@layout-manager@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #layoutManager
-- @
clearActorLayoutManager :: (MonadIO m, IsActor o) => o -> m ()
clearActorLayoutManager :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorLayoutManager o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe LayoutManager -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"layout-manager" (Maybe LayoutManager
forall a. Maybe a
Nothing :: Maybe Clutter.LayoutManager.LayoutManager)

#if defined(ENABLE_OVERLOADING)
data ActorLayoutManagerPropertyInfo
instance AttrInfo ActorLayoutManagerPropertyInfo where
    type AttrAllowedOps ActorLayoutManagerPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorLayoutManagerPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorLayoutManagerPropertyInfo = Clutter.LayoutManager.IsLayoutManager
    type AttrTransferTypeConstraint ActorLayoutManagerPropertyInfo = Clutter.LayoutManager.IsLayoutManager
    type AttrTransferType ActorLayoutManagerPropertyInfo = Clutter.LayoutManager.LayoutManager
    type AttrGetType ActorLayoutManagerPropertyInfo = Clutter.LayoutManager.LayoutManager
    type AttrLabel ActorLayoutManagerPropertyInfo = "layout-manager"
    type AttrOrigin ActorLayoutManagerPropertyInfo = Actor
    attrGet = getActorLayoutManager
    attrSet = setActorLayoutManager
    attrTransfer _ v = do
        unsafeCastTo Clutter.LayoutManager.LayoutManager v
    attrConstruct = constructActorLayoutManager
    attrClear = clearActorLayoutManager
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.layoutManager"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:layoutManager"
        })
#endif

-- VVV Prop "magnification-filter"
   -- Type: TInterface (Name {namespace = "Clutter", name = "ScalingFilter"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@magnification-filter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #magnificationFilter
-- @
getActorMagnificationFilter :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.ScalingFilter
getActorMagnificationFilter :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m ScalingFilter
getActorMagnificationFilter o
obj = IO ScalingFilter -> m ScalingFilter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ScalingFilter -> m ScalingFilter)
-> IO ScalingFilter -> m ScalingFilter
forall a b. (a -> b) -> a -> b
$ o -> String -> IO ScalingFilter
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"magnification-filter"

-- | Set the value of the “@magnification-filter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #magnificationFilter 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMagnificationFilter :: (MonadIO m, IsActor o) => o -> Clutter.Enums.ScalingFilter -> m ()
setActorMagnificationFilter :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> ScalingFilter -> m ()
setActorMagnificationFilter o
obj ScalingFilter
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ScalingFilter -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"magnification-filter" ScalingFilter
val

-- | Construct a `GValueConstruct` with valid value for the “@magnification-filter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMagnificationFilter :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.ScalingFilter -> m (GValueConstruct o)
constructActorMagnificationFilter :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
ScalingFilter -> m (GValueConstruct o)
constructActorMagnificationFilter ScalingFilter
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> ScalingFilter -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"magnification-filter" ScalingFilter
val

#if defined(ENABLE_OVERLOADING)
data ActorMagnificationFilterPropertyInfo
instance AttrInfo ActorMagnificationFilterPropertyInfo where
    type AttrAllowedOps ActorMagnificationFilterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMagnificationFilterPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMagnificationFilterPropertyInfo = (~) Clutter.Enums.ScalingFilter
    type AttrTransferTypeConstraint ActorMagnificationFilterPropertyInfo = (~) Clutter.Enums.ScalingFilter
    type AttrTransferType ActorMagnificationFilterPropertyInfo = Clutter.Enums.ScalingFilter
    type AttrGetType ActorMagnificationFilterPropertyInfo = Clutter.Enums.ScalingFilter
    type AttrLabel ActorMagnificationFilterPropertyInfo = "magnification-filter"
    type AttrOrigin ActorMagnificationFilterPropertyInfo = Actor
    attrGet = getActorMagnificationFilter
    attrSet = setActorMagnificationFilter
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMagnificationFilter
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.magnificationFilter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:magnificationFilter"
        })
#endif

-- VVV Prop "mapped"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@mapped@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #mapped
-- @
getActorMapped :: (MonadIO m, IsActor o) => o -> m Bool
getActorMapped :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorMapped o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"mapped"

#if defined(ENABLE_OVERLOADING)
data ActorMappedPropertyInfo
instance AttrInfo ActorMappedPropertyInfo where
    type AttrAllowedOps ActorMappedPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ActorMappedPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMappedPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorMappedPropertyInfo = (~) ()
    type AttrTransferType ActorMappedPropertyInfo = ()
    type AttrGetType ActorMappedPropertyInfo = Bool
    type AttrLabel ActorMappedPropertyInfo = "mapped"
    type AttrOrigin ActorMappedPropertyInfo = Actor
    attrGet = getActorMapped
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.mapped"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:mapped"
        })
#endif

-- VVV Prop "margin-bottom"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@margin-bottom@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #marginBottom
-- @
getActorMarginBottom :: (MonadIO m, IsActor o) => o -> m Float
getActorMarginBottom :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorMarginBottom o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"margin-bottom"

-- | Set the value of the “@margin-bottom@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #marginBottom 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMarginBottom :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorMarginBottom :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorMarginBottom o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"margin-bottom" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@margin-bottom@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMarginBottom :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorMarginBottom :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorMarginBottom Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"margin-bottom" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorMarginBottomPropertyInfo
instance AttrInfo ActorMarginBottomPropertyInfo where
    type AttrAllowedOps ActorMarginBottomPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMarginBottomPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMarginBottomPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorMarginBottomPropertyInfo = (~) Float
    type AttrTransferType ActorMarginBottomPropertyInfo = Float
    type AttrGetType ActorMarginBottomPropertyInfo = Float
    type AttrLabel ActorMarginBottomPropertyInfo = "margin-bottom"
    type AttrOrigin ActorMarginBottomPropertyInfo = Actor
    attrGet = getActorMarginBottom
    attrSet = setActorMarginBottom
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMarginBottom
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.marginBottom"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:marginBottom"
        })
#endif

-- VVV Prop "margin-left"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@margin-left@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #marginLeft
-- @
getActorMarginLeft :: (MonadIO m, IsActor o) => o -> m Float
getActorMarginLeft :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorMarginLeft o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"margin-left"

-- | Set the value of the “@margin-left@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #marginLeft 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMarginLeft :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorMarginLeft :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorMarginLeft o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"margin-left" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@margin-left@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMarginLeft :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorMarginLeft :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorMarginLeft Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"margin-left" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorMarginLeftPropertyInfo
instance AttrInfo ActorMarginLeftPropertyInfo where
    type AttrAllowedOps ActorMarginLeftPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMarginLeftPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMarginLeftPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorMarginLeftPropertyInfo = (~) Float
    type AttrTransferType ActorMarginLeftPropertyInfo = Float
    type AttrGetType ActorMarginLeftPropertyInfo = Float
    type AttrLabel ActorMarginLeftPropertyInfo = "margin-left"
    type AttrOrigin ActorMarginLeftPropertyInfo = Actor
    attrGet = getActorMarginLeft
    attrSet = setActorMarginLeft
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMarginLeft
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.marginLeft"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:marginLeft"
        })
#endif

-- VVV Prop "margin-right"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@margin-right@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #marginRight
-- @
getActorMarginRight :: (MonadIO m, IsActor o) => o -> m Float
getActorMarginRight :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorMarginRight o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"margin-right"

-- | Set the value of the “@margin-right@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #marginRight 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMarginRight :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorMarginRight :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorMarginRight o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"margin-right" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@margin-right@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMarginRight :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorMarginRight :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorMarginRight Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"margin-right" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorMarginRightPropertyInfo
instance AttrInfo ActorMarginRightPropertyInfo where
    type AttrAllowedOps ActorMarginRightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMarginRightPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMarginRightPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorMarginRightPropertyInfo = (~) Float
    type AttrTransferType ActorMarginRightPropertyInfo = Float
    type AttrGetType ActorMarginRightPropertyInfo = Float
    type AttrLabel ActorMarginRightPropertyInfo = "margin-right"
    type AttrOrigin ActorMarginRightPropertyInfo = Actor
    attrGet = getActorMarginRight
    attrSet = setActorMarginRight
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMarginRight
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.marginRight"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:marginRight"
        })
#endif

-- VVV Prop "margin-top"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@margin-top@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #marginTop
-- @
getActorMarginTop :: (MonadIO m, IsActor o) => o -> m Float
getActorMarginTop :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorMarginTop o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"margin-top"

-- | Set the value of the “@margin-top@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #marginTop 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMarginTop :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorMarginTop :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorMarginTop o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"margin-top" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@margin-top@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMarginTop :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorMarginTop :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorMarginTop Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"margin-top" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorMarginTopPropertyInfo
instance AttrInfo ActorMarginTopPropertyInfo where
    type AttrAllowedOps ActorMarginTopPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMarginTopPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMarginTopPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorMarginTopPropertyInfo = (~) Float
    type AttrTransferType ActorMarginTopPropertyInfo = Float
    type AttrGetType ActorMarginTopPropertyInfo = Float
    type AttrLabel ActorMarginTopPropertyInfo = "margin-top"
    type AttrOrigin ActorMarginTopPropertyInfo = Actor
    attrGet = getActorMarginTop
    attrSet = setActorMarginTop
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMarginTop
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.marginTop"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:marginTop"
        })
#endif

-- VVV Prop "min-height"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@min-height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #minHeight
-- @
getActorMinHeight :: (MonadIO m, IsActor o) => o -> m Float
getActorMinHeight :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorMinHeight o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"min-height"

-- | Set the value of the “@min-height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #minHeight 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMinHeight :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorMinHeight :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorMinHeight o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"min-height" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@min-height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMinHeight :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorMinHeight :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorMinHeight Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"min-height" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorMinHeightPropertyInfo
instance AttrInfo ActorMinHeightPropertyInfo where
    type AttrAllowedOps ActorMinHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMinHeightPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMinHeightPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorMinHeightPropertyInfo = (~) Float
    type AttrTransferType ActorMinHeightPropertyInfo = Float
    type AttrGetType ActorMinHeightPropertyInfo = Float
    type AttrLabel ActorMinHeightPropertyInfo = "min-height"
    type AttrOrigin ActorMinHeightPropertyInfo = Actor
    attrGet = getActorMinHeight
    attrSet = setActorMinHeight
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMinHeight
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.minHeight"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:minHeight"
        })
#endif

-- VVV Prop "min-height-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@min-height-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #minHeightSet
-- @
getActorMinHeightSet :: (MonadIO m, IsActor o) => o -> m Bool
getActorMinHeightSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorMinHeightSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"min-height-set"

-- | Set the value of the “@min-height-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #minHeightSet 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMinHeightSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorMinHeightSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorMinHeightSet o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"min-height-set" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@min-height-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMinHeightSet :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorMinHeightSet :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorMinHeightSet Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"min-height-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorMinHeightSetPropertyInfo
instance AttrInfo ActorMinHeightSetPropertyInfo where
    type AttrAllowedOps ActorMinHeightSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMinHeightSetPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMinHeightSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorMinHeightSetPropertyInfo = (~) Bool
    type AttrTransferType ActorMinHeightSetPropertyInfo = Bool
    type AttrGetType ActorMinHeightSetPropertyInfo = Bool
    type AttrLabel ActorMinHeightSetPropertyInfo = "min-height-set"
    type AttrOrigin ActorMinHeightSetPropertyInfo = Actor
    attrGet = getActorMinHeightSet
    attrSet = setActorMinHeightSet
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMinHeightSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.minHeightSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:minHeightSet"
        })
#endif

-- VVV Prop "min-width"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@min-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #minWidth
-- @
getActorMinWidth :: (MonadIO m, IsActor o) => o -> m Float
getActorMinWidth :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorMinWidth o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"min-width"

-- | Set the value of the “@min-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #minWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMinWidth :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorMinWidth :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorMinWidth o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"min-width" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@min-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMinWidth :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorMinWidth :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorMinWidth Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"min-width" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorMinWidthPropertyInfo
instance AttrInfo ActorMinWidthPropertyInfo where
    type AttrAllowedOps ActorMinWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMinWidthPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMinWidthPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorMinWidthPropertyInfo = (~) Float
    type AttrTransferType ActorMinWidthPropertyInfo = Float
    type AttrGetType ActorMinWidthPropertyInfo = Float
    type AttrLabel ActorMinWidthPropertyInfo = "min-width"
    type AttrOrigin ActorMinWidthPropertyInfo = Actor
    attrGet = getActorMinWidth
    attrSet = setActorMinWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMinWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.minWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:minWidth"
        })
#endif

-- VVV Prop "min-width-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@min-width-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #minWidthSet
-- @
getActorMinWidthSet :: (MonadIO m, IsActor o) => o -> m Bool
getActorMinWidthSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorMinWidthSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"min-width-set"

-- | Set the value of the “@min-width-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #minWidthSet 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMinWidthSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorMinWidthSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorMinWidthSet o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"min-width-set" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@min-width-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMinWidthSet :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorMinWidthSet :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorMinWidthSet Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"min-width-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorMinWidthSetPropertyInfo
instance AttrInfo ActorMinWidthSetPropertyInfo where
    type AttrAllowedOps ActorMinWidthSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMinWidthSetPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMinWidthSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorMinWidthSetPropertyInfo = (~) Bool
    type AttrTransferType ActorMinWidthSetPropertyInfo = Bool
    type AttrGetType ActorMinWidthSetPropertyInfo = Bool
    type AttrLabel ActorMinWidthSetPropertyInfo = "min-width-set"
    type AttrOrigin ActorMinWidthSetPropertyInfo = Actor
    attrGet = getActorMinWidthSet
    attrSet = setActorMinWidthSet
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMinWidthSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.minWidthSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:minWidthSet"
        })
#endif

-- VVV Prop "minification-filter"
   -- Type: TInterface (Name {namespace = "Clutter", name = "ScalingFilter"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@minification-filter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #minificationFilter
-- @
getActorMinificationFilter :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.ScalingFilter
getActorMinificationFilter :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m ScalingFilter
getActorMinificationFilter o
obj = IO ScalingFilter -> m ScalingFilter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ScalingFilter -> m ScalingFilter)
-> IO ScalingFilter -> m ScalingFilter
forall a b. (a -> b) -> a -> b
$ o -> String -> IO ScalingFilter
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"minification-filter"

-- | Set the value of the “@minification-filter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #minificationFilter 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorMinificationFilter :: (MonadIO m, IsActor o) => o -> Clutter.Enums.ScalingFilter -> m ()
setActorMinificationFilter :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> ScalingFilter -> m ()
setActorMinificationFilter o
obj ScalingFilter
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ScalingFilter -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"minification-filter" ScalingFilter
val

-- | Construct a `GValueConstruct` with valid value for the “@minification-filter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorMinificationFilter :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.ScalingFilter -> m (GValueConstruct o)
constructActorMinificationFilter :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
ScalingFilter -> m (GValueConstruct o)
constructActorMinificationFilter ScalingFilter
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> ScalingFilter -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"minification-filter" ScalingFilter
val

#if defined(ENABLE_OVERLOADING)
data ActorMinificationFilterPropertyInfo
instance AttrInfo ActorMinificationFilterPropertyInfo where
    type AttrAllowedOps ActorMinificationFilterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorMinificationFilterPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorMinificationFilterPropertyInfo = (~) Clutter.Enums.ScalingFilter
    type AttrTransferTypeConstraint ActorMinificationFilterPropertyInfo = (~) Clutter.Enums.ScalingFilter
    type AttrTransferType ActorMinificationFilterPropertyInfo = Clutter.Enums.ScalingFilter
    type AttrGetType ActorMinificationFilterPropertyInfo = Clutter.Enums.ScalingFilter
    type AttrLabel ActorMinificationFilterPropertyInfo = "minification-filter"
    type AttrOrigin ActorMinificationFilterPropertyInfo = Actor
    attrGet = getActorMinificationFilter
    attrSet = setActorMinificationFilter
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorMinificationFilter
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.minificationFilter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:minificationFilter"
        })
#endif

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #name
-- @
getActorName :: (MonadIO m, IsActor o) => o -> m T.Text
getActorName :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Text
getActorName o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getActorName" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"name"

-- | Set the value of the “@name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #name 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorName :: (MonadIO m, IsActor o) => o -> T.Text -> m ()
setActorName :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Text -> m ()
setActorName o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorName :: (IsActor o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructActorName :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructActorName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data ActorNamePropertyInfo
instance AttrInfo ActorNamePropertyInfo where
    type AttrAllowedOps ActorNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorNamePropertyInfo = IsActor
    type AttrSetTypeConstraint ActorNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ActorNamePropertyInfo = (~) T.Text
    type AttrTransferType ActorNamePropertyInfo = T.Text
    type AttrGetType ActorNamePropertyInfo = T.Text
    type AttrLabel ActorNamePropertyInfo = "name"
    type AttrOrigin ActorNamePropertyInfo = Actor
    attrGet = getActorName
    attrSet = setActorName
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorName
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.name"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:name"
        })
#endif

-- VVV Prop "natural-height"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@natural-height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #naturalHeight
-- @
getActorNaturalHeight :: (MonadIO m, IsActor o) => o -> m Float
getActorNaturalHeight :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorNaturalHeight o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"natural-height"

-- | Set the value of the “@natural-height@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #naturalHeight 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorNaturalHeight :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorNaturalHeight :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorNaturalHeight o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"natural-height" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@natural-height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorNaturalHeight :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorNaturalHeight :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorNaturalHeight Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"natural-height" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorNaturalHeightPropertyInfo
instance AttrInfo ActorNaturalHeightPropertyInfo where
    type AttrAllowedOps ActorNaturalHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorNaturalHeightPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorNaturalHeightPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorNaturalHeightPropertyInfo = (~) Float
    type AttrTransferType ActorNaturalHeightPropertyInfo = Float
    type AttrGetType ActorNaturalHeightPropertyInfo = Float
    type AttrLabel ActorNaturalHeightPropertyInfo = "natural-height"
    type AttrOrigin ActorNaturalHeightPropertyInfo = Actor
    attrGet = getActorNaturalHeight
    attrSet = setActorNaturalHeight
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorNaturalHeight
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.naturalHeight"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:naturalHeight"
        })
#endif

-- VVV Prop "natural-height-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@natural-height-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #naturalHeightSet
-- @
getActorNaturalHeightSet :: (MonadIO m, IsActor o) => o -> m Bool
getActorNaturalHeightSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorNaturalHeightSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"natural-height-set"

-- | Set the value of the “@natural-height-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #naturalHeightSet 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorNaturalHeightSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorNaturalHeightSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorNaturalHeightSet o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"natural-height-set" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@natural-height-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorNaturalHeightSet :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorNaturalHeightSet :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorNaturalHeightSet Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"natural-height-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorNaturalHeightSetPropertyInfo
instance AttrInfo ActorNaturalHeightSetPropertyInfo where
    type AttrAllowedOps ActorNaturalHeightSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorNaturalHeightSetPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorNaturalHeightSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorNaturalHeightSetPropertyInfo = (~) Bool
    type AttrTransferType ActorNaturalHeightSetPropertyInfo = Bool
    type AttrGetType ActorNaturalHeightSetPropertyInfo = Bool
    type AttrLabel ActorNaturalHeightSetPropertyInfo = "natural-height-set"
    type AttrOrigin ActorNaturalHeightSetPropertyInfo = Actor
    attrGet = getActorNaturalHeightSet
    attrSet = setActorNaturalHeightSet
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorNaturalHeightSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.naturalHeightSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:naturalHeightSet"
        })
#endif

-- VVV Prop "natural-width"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@natural-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #naturalWidth
-- @
getActorNaturalWidth :: (MonadIO m, IsActor o) => o -> m Float
getActorNaturalWidth :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorNaturalWidth o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"natural-width"

-- | Set the value of the “@natural-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #naturalWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorNaturalWidth :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorNaturalWidth :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorNaturalWidth o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"natural-width" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@natural-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorNaturalWidth :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorNaturalWidth :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorNaturalWidth Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"natural-width" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorNaturalWidthPropertyInfo
instance AttrInfo ActorNaturalWidthPropertyInfo where
    type AttrAllowedOps ActorNaturalWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorNaturalWidthPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorNaturalWidthPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorNaturalWidthPropertyInfo = (~) Float
    type AttrTransferType ActorNaturalWidthPropertyInfo = Float
    type AttrGetType ActorNaturalWidthPropertyInfo = Float
    type AttrLabel ActorNaturalWidthPropertyInfo = "natural-width"
    type AttrOrigin ActorNaturalWidthPropertyInfo = Actor
    attrGet = getActorNaturalWidth
    attrSet = setActorNaturalWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorNaturalWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.naturalWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:naturalWidth"
        })
#endif

-- VVV Prop "natural-width-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@natural-width-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #naturalWidthSet
-- @
getActorNaturalWidthSet :: (MonadIO m, IsActor o) => o -> m Bool
getActorNaturalWidthSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorNaturalWidthSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"natural-width-set"

-- | Set the value of the “@natural-width-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #naturalWidthSet 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorNaturalWidthSet :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorNaturalWidthSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorNaturalWidthSet o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"natural-width-set" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@natural-width-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorNaturalWidthSet :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorNaturalWidthSet :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorNaturalWidthSet Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"natural-width-set" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorNaturalWidthSetPropertyInfo
instance AttrInfo ActorNaturalWidthSetPropertyInfo where
    type AttrAllowedOps ActorNaturalWidthSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorNaturalWidthSetPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorNaturalWidthSetPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorNaturalWidthSetPropertyInfo = (~) Bool
    type AttrTransferType ActorNaturalWidthSetPropertyInfo = Bool
    type AttrGetType ActorNaturalWidthSetPropertyInfo = Bool
    type AttrLabel ActorNaturalWidthSetPropertyInfo = "natural-width-set"
    type AttrOrigin ActorNaturalWidthSetPropertyInfo = Actor
    attrGet = getActorNaturalWidthSet
    attrSet = setActorNaturalWidthSet
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorNaturalWidthSet
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.naturalWidthSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:naturalWidthSet"
        })
#endif

-- VVV Prop "offscreen-redirect"
   -- Type: TInterface (Name {namespace = "Clutter", name = "OffscreenRedirect"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@offscreen-redirect@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #offscreenRedirect
-- @
getActorOffscreenRedirect :: (MonadIO m, IsActor o) => o -> m [Clutter.Flags.OffscreenRedirect]
getActorOffscreenRedirect :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m [OffscreenRedirect]
getActorOffscreenRedirect o
obj = IO [OffscreenRedirect] -> m [OffscreenRedirect]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [OffscreenRedirect] -> m [OffscreenRedirect])
-> IO [OffscreenRedirect] -> m [OffscreenRedirect]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [OffscreenRedirect]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"offscreen-redirect"

-- | Set the value of the “@offscreen-redirect@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #offscreenRedirect 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorOffscreenRedirect :: (MonadIO m, IsActor o) => o -> [Clutter.Flags.OffscreenRedirect] -> m ()
setActorOffscreenRedirect :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> [OffscreenRedirect] -> m ()
setActorOffscreenRedirect o
obj [OffscreenRedirect]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> [OffscreenRedirect] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"offscreen-redirect" [OffscreenRedirect]
val

-- | Construct a `GValueConstruct` with valid value for the “@offscreen-redirect@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorOffscreenRedirect :: (IsActor o, MIO.MonadIO m) => [Clutter.Flags.OffscreenRedirect] -> m (GValueConstruct o)
constructActorOffscreenRedirect :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
[OffscreenRedirect] -> m (GValueConstruct o)
constructActorOffscreenRedirect [OffscreenRedirect]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [OffscreenRedirect] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"offscreen-redirect" [OffscreenRedirect]
val

#if defined(ENABLE_OVERLOADING)
data ActorOffscreenRedirectPropertyInfo
instance AttrInfo ActorOffscreenRedirectPropertyInfo where
    type AttrAllowedOps ActorOffscreenRedirectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorOffscreenRedirectPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorOffscreenRedirectPropertyInfo = (~) [Clutter.Flags.OffscreenRedirect]
    type AttrTransferTypeConstraint ActorOffscreenRedirectPropertyInfo = (~) [Clutter.Flags.OffscreenRedirect]
    type AttrTransferType ActorOffscreenRedirectPropertyInfo = [Clutter.Flags.OffscreenRedirect]
    type AttrGetType ActorOffscreenRedirectPropertyInfo = [Clutter.Flags.OffscreenRedirect]
    type AttrLabel ActorOffscreenRedirectPropertyInfo = "offscreen-redirect"
    type AttrOrigin ActorOffscreenRedirectPropertyInfo = Actor
    attrGet = getActorOffscreenRedirect
    attrSet = setActorOffscreenRedirect
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorOffscreenRedirect
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.offscreenRedirect"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:offscreenRedirect"
        })
#endif

-- VVV Prop "opacity"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@opacity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #opacity
-- @
getActorOpacity :: (MonadIO m, IsActor o) => o -> m Word32
getActorOpacity :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Word32
getActorOpacity o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"opacity"

-- | Set the value of the “@opacity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #opacity 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorOpacity :: (MonadIO m, IsActor o) => o -> Word32 -> m ()
setActorOpacity :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Word32 -> m ()
setActorOpacity o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"opacity" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@opacity@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorOpacity :: (IsActor o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructActorOpacity :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructActorOpacity Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"opacity" Word32
val

#if defined(ENABLE_OVERLOADING)
data ActorOpacityPropertyInfo
instance AttrInfo ActorOpacityPropertyInfo where
    type AttrAllowedOps ActorOpacityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorOpacityPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorOpacityPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint ActorOpacityPropertyInfo = (~) Word32
    type AttrTransferType ActorOpacityPropertyInfo = Word32
    type AttrGetType ActorOpacityPropertyInfo = Word32
    type AttrLabel ActorOpacityPropertyInfo = "opacity"
    type AttrOrigin ActorOpacityPropertyInfo = Actor
    attrGet = getActorOpacity
    attrSet = setActorOpacity
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorOpacity
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.opacity"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:opacity"
        })
#endif

-- VVV Prop "pivot-point"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Point"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@pivot-point@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #pivotPoint
-- @
getActorPivotPoint :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Point.Point)
getActorPivotPoint :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Point)
getActorPivotPoint o
obj = IO (Maybe Point) -> m (Maybe Point)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Point) -> m (Maybe Point))
-> IO (Maybe Point) -> m (Maybe Point)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Point -> Point) -> IO (Maybe Point)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"pivot-point" ManagedPtr Point -> Point
Clutter.Point.Point

-- | Set the value of the “@pivot-point@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #pivotPoint 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorPivotPoint :: (MonadIO m, IsActor o) => o -> Clutter.Point.Point -> m ()
setActorPivotPoint :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Point -> m ()
setActorPivotPoint o
obj Point
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Point -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"pivot-point" (Point -> Maybe Point
forall a. a -> Maybe a
Just Point
val)

-- | Construct a `GValueConstruct` with valid value for the “@pivot-point@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorPivotPoint :: (IsActor o, MIO.MonadIO m) => Clutter.Point.Point -> m (GValueConstruct o)
constructActorPivotPoint :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Point -> m (GValueConstruct o)
constructActorPivotPoint Point
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Point -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"pivot-point" (Point -> Maybe Point
forall a. a -> Maybe a
P.Just Point
val)

-- | Set the value of the “@pivot-point@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #pivotPoint
-- @
clearActorPivotPoint :: (MonadIO m, IsActor o) => o -> m ()
clearActorPivotPoint :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorPivotPoint o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Point -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"pivot-point" (Maybe Point
forall a. Maybe a
Nothing :: Maybe Clutter.Point.Point)

#if defined(ENABLE_OVERLOADING)
data ActorPivotPointPropertyInfo
instance AttrInfo ActorPivotPointPropertyInfo where
    type AttrAllowedOps ActorPivotPointPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorPivotPointPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorPivotPointPropertyInfo = (~) Clutter.Point.Point
    type AttrTransferTypeConstraint ActorPivotPointPropertyInfo = (~) Clutter.Point.Point
    type AttrTransferType ActorPivotPointPropertyInfo = Clutter.Point.Point
    type AttrGetType ActorPivotPointPropertyInfo = (Maybe Clutter.Point.Point)
    type AttrLabel ActorPivotPointPropertyInfo = "pivot-point"
    type AttrOrigin ActorPivotPointPropertyInfo = Actor
    attrGet = getActorPivotPoint
    attrSet = setActorPivotPoint
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorPivotPoint
    attrClear = clearActorPivotPoint
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.pivotPoint"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:pivotPoint"
        })
#endif

-- VVV Prop "pivot-point-z"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@pivot-point-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #pivotPointZ
-- @
getActorPivotPointZ :: (MonadIO m, IsActor o) => o -> m Float
getActorPivotPointZ :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorPivotPointZ o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"pivot-point-z"

-- | Set the value of the “@pivot-point-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #pivotPointZ 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorPivotPointZ :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorPivotPointZ :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorPivotPointZ o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"pivot-point-z" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@pivot-point-z@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorPivotPointZ :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorPivotPointZ :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorPivotPointZ Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"pivot-point-z" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorPivotPointZPropertyInfo
instance AttrInfo ActorPivotPointZPropertyInfo where
    type AttrAllowedOps ActorPivotPointZPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorPivotPointZPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorPivotPointZPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorPivotPointZPropertyInfo = (~) Float
    type AttrTransferType ActorPivotPointZPropertyInfo = Float
    type AttrGetType ActorPivotPointZPropertyInfo = Float
    type AttrLabel ActorPivotPointZPropertyInfo = "pivot-point-z"
    type AttrOrigin ActorPivotPointZPropertyInfo = Actor
    attrGet = getActorPivotPointZ
    attrSet = setActorPivotPointZ
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorPivotPointZ
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.pivotPointZ"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:pivotPointZ"
        })
#endif

-- VVV Prop "position"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Point"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@position@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #position
-- @
getActorPosition :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Point.Point)
getActorPosition :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Point)
getActorPosition o
obj = IO (Maybe Point) -> m (Maybe Point)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Point) -> m (Maybe Point))
-> IO (Maybe Point) -> m (Maybe Point)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Point -> Point) -> IO (Maybe Point)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"position" ManagedPtr Point -> Point
Clutter.Point.Point

-- | Set the value of the “@position@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #position 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorPosition :: (MonadIO m, IsActor o) => o -> Clutter.Point.Point -> m ()
setActorPosition :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Point -> m ()
setActorPosition o
obj Point
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Point -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"position" (Point -> Maybe Point
forall a. a -> Maybe a
Just Point
val)

-- | Construct a `GValueConstruct` with valid value for the “@position@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorPosition :: (IsActor o, MIO.MonadIO m) => Clutter.Point.Point -> m (GValueConstruct o)
constructActorPosition :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Point -> m (GValueConstruct o)
constructActorPosition Point
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Point -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"position" (Point -> Maybe Point
forall a. a -> Maybe a
P.Just Point
val)

-- | Set the value of the “@position@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #position
-- @
clearActorPosition :: (MonadIO m, IsActor o) => o -> m ()
clearActorPosition :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorPosition o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Point -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"position" (Maybe Point
forall a. Maybe a
Nothing :: Maybe Clutter.Point.Point)

#if defined(ENABLE_OVERLOADING)
data ActorPositionPropertyInfo
instance AttrInfo ActorPositionPropertyInfo where
    type AttrAllowedOps ActorPositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorPositionPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorPositionPropertyInfo = (~) Clutter.Point.Point
    type AttrTransferTypeConstraint ActorPositionPropertyInfo = (~) Clutter.Point.Point
    type AttrTransferType ActorPositionPropertyInfo = Clutter.Point.Point
    type AttrGetType ActorPositionPropertyInfo = (Maybe Clutter.Point.Point)
    type AttrLabel ActorPositionPropertyInfo = "position"
    type AttrOrigin ActorPositionPropertyInfo = Actor
    attrGet = getActorPosition
    attrSet = setActorPosition
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorPosition
    attrClear = clearActorPosition
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.position"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:position"
        })
#endif

-- VVV Prop "reactive"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@reactive@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #reactive
-- @
getActorReactive :: (MonadIO m, IsActor o) => o -> m Bool
getActorReactive :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorReactive o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"reactive"

-- | Set the value of the “@reactive@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #reactive 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorReactive :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorReactive :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorReactive o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"reactive" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@reactive@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorReactive :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorReactive :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorReactive Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"reactive" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorReactivePropertyInfo
instance AttrInfo ActorReactivePropertyInfo where
    type AttrAllowedOps ActorReactivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorReactivePropertyInfo = IsActor
    type AttrSetTypeConstraint ActorReactivePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorReactivePropertyInfo = (~) Bool
    type AttrTransferType ActorReactivePropertyInfo = Bool
    type AttrGetType ActorReactivePropertyInfo = Bool
    type AttrLabel ActorReactivePropertyInfo = "reactive"
    type AttrOrigin ActorReactivePropertyInfo = Actor
    attrGet = getActorReactive
    attrSet = setActorReactive
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorReactive
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.reactive"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:reactive"
        })
#endif

-- VVV Prop "realized"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@realized@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #realized
-- @
getActorRealized :: (MonadIO m, IsActor o) => o -> m Bool
getActorRealized :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorRealized o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"realized"

#if defined(ENABLE_OVERLOADING)
data ActorRealizedPropertyInfo
instance AttrInfo ActorRealizedPropertyInfo where
    type AttrAllowedOps ActorRealizedPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ActorRealizedPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRealizedPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorRealizedPropertyInfo = (~) ()
    type AttrTransferType ActorRealizedPropertyInfo = ()
    type AttrGetType ActorRealizedPropertyInfo = Bool
    type AttrLabel ActorRealizedPropertyInfo = "realized"
    type AttrOrigin ActorRealizedPropertyInfo = Actor
    attrGet = getActorRealized
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.realized"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:realized"
        })
#endif

-- VVV Prop "request-mode"
   -- Type: TInterface (Name {namespace = "Clutter", name = "RequestMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@request-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #requestMode
-- @
getActorRequestMode :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.RequestMode
getActorRequestMode :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m RequestMode
getActorRequestMode o
obj = IO RequestMode -> m RequestMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO RequestMode -> m RequestMode)
-> IO RequestMode -> m RequestMode
forall a b. (a -> b) -> a -> b
$ o -> String -> IO RequestMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"request-mode"

-- | Set the value of the “@request-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #requestMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorRequestMode :: (MonadIO m, IsActor o) => o -> Clutter.Enums.RequestMode -> m ()
setActorRequestMode :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> RequestMode -> m ()
setActorRequestMode o
obj RequestMode
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> RequestMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"request-mode" RequestMode
val

-- | Construct a `GValueConstruct` with valid value for the “@request-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorRequestMode :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.RequestMode -> m (GValueConstruct o)
constructActorRequestMode :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
RequestMode -> m (GValueConstruct o)
constructActorRequestMode RequestMode
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> RequestMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"request-mode" RequestMode
val

#if defined(ENABLE_OVERLOADING)
data ActorRequestModePropertyInfo
instance AttrInfo ActorRequestModePropertyInfo where
    type AttrAllowedOps ActorRequestModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorRequestModePropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRequestModePropertyInfo = (~) Clutter.Enums.RequestMode
    type AttrTransferTypeConstraint ActorRequestModePropertyInfo = (~) Clutter.Enums.RequestMode
    type AttrTransferType ActorRequestModePropertyInfo = Clutter.Enums.RequestMode
    type AttrGetType ActorRequestModePropertyInfo = Clutter.Enums.RequestMode
    type AttrLabel ActorRequestModePropertyInfo = "request-mode"
    type AttrOrigin ActorRequestModePropertyInfo = Actor
    attrGet = getActorRequestMode
    attrSet = setActorRequestMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorRequestMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.requestMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:requestMode"
        })
#endif

-- VVV Prop "rotation-angle-x"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@rotation-angle-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #rotationAngleX
-- @
getActorRotationAngleX :: (MonadIO m, IsActor o) => o -> m Double
getActorRotationAngleX :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Double
getActorRotationAngleX o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"rotation-angle-x"

-- | Set the value of the “@rotation-angle-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #rotationAngleX 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorRotationAngleX :: (MonadIO m, IsActor o) => o -> Double -> m ()
setActorRotationAngleX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Double -> m ()
setActorRotationAngleX o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"rotation-angle-x" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@rotation-angle-x@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorRotationAngleX :: (IsActor o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructActorRotationAngleX :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructActorRotationAngleX Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"rotation-angle-x" Double
val

#if defined(ENABLE_OVERLOADING)
data ActorRotationAngleXPropertyInfo
instance AttrInfo ActorRotationAngleXPropertyInfo where
    type AttrAllowedOps ActorRotationAngleXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorRotationAngleXPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRotationAngleXPropertyInfo = (~) Double
    type AttrTransferTypeConstraint ActorRotationAngleXPropertyInfo = (~) Double
    type AttrTransferType ActorRotationAngleXPropertyInfo = Double
    type AttrGetType ActorRotationAngleXPropertyInfo = Double
    type AttrLabel ActorRotationAngleXPropertyInfo = "rotation-angle-x"
    type AttrOrigin ActorRotationAngleXPropertyInfo = Actor
    attrGet = getActorRotationAngleX
    attrSet = setActorRotationAngleX
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorRotationAngleX
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.rotationAngleX"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:rotationAngleX"
        })
#endif

-- VVV Prop "rotation-angle-y"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@rotation-angle-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #rotationAngleY
-- @
getActorRotationAngleY :: (MonadIO m, IsActor o) => o -> m Double
getActorRotationAngleY :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Double
getActorRotationAngleY o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"rotation-angle-y"

-- | Set the value of the “@rotation-angle-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #rotationAngleY 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorRotationAngleY :: (MonadIO m, IsActor o) => o -> Double -> m ()
setActorRotationAngleY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Double -> m ()
setActorRotationAngleY o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"rotation-angle-y" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@rotation-angle-y@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorRotationAngleY :: (IsActor o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructActorRotationAngleY :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructActorRotationAngleY Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"rotation-angle-y" Double
val

#if defined(ENABLE_OVERLOADING)
data ActorRotationAngleYPropertyInfo
instance AttrInfo ActorRotationAngleYPropertyInfo where
    type AttrAllowedOps ActorRotationAngleYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorRotationAngleYPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRotationAngleYPropertyInfo = (~) Double
    type AttrTransferTypeConstraint ActorRotationAngleYPropertyInfo = (~) Double
    type AttrTransferType ActorRotationAngleYPropertyInfo = Double
    type AttrGetType ActorRotationAngleYPropertyInfo = Double
    type AttrLabel ActorRotationAngleYPropertyInfo = "rotation-angle-y"
    type AttrOrigin ActorRotationAngleYPropertyInfo = Actor
    attrGet = getActorRotationAngleY
    attrSet = setActorRotationAngleY
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorRotationAngleY
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.rotationAngleY"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:rotationAngleY"
        })
#endif

-- VVV Prop "rotation-angle-z"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@rotation-angle-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #rotationAngleZ
-- @
getActorRotationAngleZ :: (MonadIO m, IsActor o) => o -> m Double
getActorRotationAngleZ :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Double
getActorRotationAngleZ o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"rotation-angle-z"

-- | Set the value of the “@rotation-angle-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #rotationAngleZ 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorRotationAngleZ :: (MonadIO m, IsActor o) => o -> Double -> m ()
setActorRotationAngleZ :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Double -> m ()
setActorRotationAngleZ o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"rotation-angle-z" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@rotation-angle-z@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorRotationAngleZ :: (IsActor o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructActorRotationAngleZ :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructActorRotationAngleZ Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"rotation-angle-z" Double
val

#if defined(ENABLE_OVERLOADING)
data ActorRotationAngleZPropertyInfo
instance AttrInfo ActorRotationAngleZPropertyInfo where
    type AttrAllowedOps ActorRotationAngleZPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorRotationAngleZPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRotationAngleZPropertyInfo = (~) Double
    type AttrTransferTypeConstraint ActorRotationAngleZPropertyInfo = (~) Double
    type AttrTransferType ActorRotationAngleZPropertyInfo = Double
    type AttrGetType ActorRotationAngleZPropertyInfo = Double
    type AttrLabel ActorRotationAngleZPropertyInfo = "rotation-angle-z"
    type AttrOrigin ActorRotationAngleZPropertyInfo = Actor
    attrGet = getActorRotationAngleZ
    attrSet = setActorRotationAngleZ
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorRotationAngleZ
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.rotationAngleZ"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:rotationAngleZ"
        })
#endif

-- VVV Prop "rotation-center-x"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Vertex"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@rotation-center-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #rotationCenterX
-- @
getActorRotationCenterX :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Vertex.Vertex)
getActorRotationCenterX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Vertex)
getActorRotationCenterX o
obj = IO (Maybe Vertex) -> m (Maybe Vertex)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Vertex) -> m (Maybe Vertex))
-> IO (Maybe Vertex) -> m (Maybe Vertex)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Vertex -> Vertex) -> IO (Maybe Vertex)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"rotation-center-x" ManagedPtr Vertex -> Vertex
Clutter.Vertex.Vertex

-- | Set the value of the “@rotation-center-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #rotationCenterX 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorRotationCenterX :: (MonadIO m, IsActor o) => o -> Clutter.Vertex.Vertex -> m ()
setActorRotationCenterX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Vertex -> m ()
setActorRotationCenterX o
obj Vertex
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Vertex -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"rotation-center-x" (Vertex -> Maybe Vertex
forall a. a -> Maybe a
Just Vertex
val)

-- | Construct a `GValueConstruct` with valid value for the “@rotation-center-x@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorRotationCenterX :: (IsActor o, MIO.MonadIO m) => Clutter.Vertex.Vertex -> m (GValueConstruct o)
constructActorRotationCenterX :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Vertex -> m (GValueConstruct o)
constructActorRotationCenterX Vertex
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Vertex -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"rotation-center-x" (Vertex -> Maybe Vertex
forall a. a -> Maybe a
P.Just Vertex
val)

-- | Set the value of the “@rotation-center-x@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #rotationCenterX
-- @
clearActorRotationCenterX :: (MonadIO m, IsActor o) => o -> m ()
clearActorRotationCenterX :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorRotationCenterX o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Vertex -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"rotation-center-x" (Maybe Vertex
forall a. Maybe a
Nothing :: Maybe Clutter.Vertex.Vertex)

#if defined(ENABLE_OVERLOADING)
data ActorRotationCenterXPropertyInfo
instance AttrInfo ActorRotationCenterXPropertyInfo where
    type AttrAllowedOps ActorRotationCenterXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorRotationCenterXPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRotationCenterXPropertyInfo = (~) Clutter.Vertex.Vertex
    type AttrTransferTypeConstraint ActorRotationCenterXPropertyInfo = (~) Clutter.Vertex.Vertex
    type AttrTransferType ActorRotationCenterXPropertyInfo = Clutter.Vertex.Vertex
    type AttrGetType ActorRotationCenterXPropertyInfo = (Maybe Clutter.Vertex.Vertex)
    type AttrLabel ActorRotationCenterXPropertyInfo = "rotation-center-x"
    type AttrOrigin ActorRotationCenterXPropertyInfo = Actor
    attrGet = getActorRotationCenterX
    attrSet = setActorRotationCenterX
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorRotationCenterX
    attrClear = clearActorRotationCenterX
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.rotationCenterX"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:rotationCenterX"
        })
#endif

-- VVV Prop "rotation-center-y"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Vertex"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@rotation-center-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #rotationCenterY
-- @
getActorRotationCenterY :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Vertex.Vertex)
getActorRotationCenterY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Vertex)
getActorRotationCenterY o
obj = IO (Maybe Vertex) -> m (Maybe Vertex)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Vertex) -> m (Maybe Vertex))
-> IO (Maybe Vertex) -> m (Maybe Vertex)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Vertex -> Vertex) -> IO (Maybe Vertex)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"rotation-center-y" ManagedPtr Vertex -> Vertex
Clutter.Vertex.Vertex

-- | Set the value of the “@rotation-center-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #rotationCenterY 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorRotationCenterY :: (MonadIO m, IsActor o) => o -> Clutter.Vertex.Vertex -> m ()
setActorRotationCenterY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Vertex -> m ()
setActorRotationCenterY o
obj Vertex
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Vertex -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"rotation-center-y" (Vertex -> Maybe Vertex
forall a. a -> Maybe a
Just Vertex
val)

-- | Construct a `GValueConstruct` with valid value for the “@rotation-center-y@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorRotationCenterY :: (IsActor o, MIO.MonadIO m) => Clutter.Vertex.Vertex -> m (GValueConstruct o)
constructActorRotationCenterY :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Vertex -> m (GValueConstruct o)
constructActorRotationCenterY Vertex
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Vertex -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"rotation-center-y" (Vertex -> Maybe Vertex
forall a. a -> Maybe a
P.Just Vertex
val)

-- | Set the value of the “@rotation-center-y@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #rotationCenterY
-- @
clearActorRotationCenterY :: (MonadIO m, IsActor o) => o -> m ()
clearActorRotationCenterY :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorRotationCenterY o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Vertex -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"rotation-center-y" (Maybe Vertex
forall a. Maybe a
Nothing :: Maybe Clutter.Vertex.Vertex)

#if defined(ENABLE_OVERLOADING)
data ActorRotationCenterYPropertyInfo
instance AttrInfo ActorRotationCenterYPropertyInfo where
    type AttrAllowedOps ActorRotationCenterYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorRotationCenterYPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRotationCenterYPropertyInfo = (~) Clutter.Vertex.Vertex
    type AttrTransferTypeConstraint ActorRotationCenterYPropertyInfo = (~) Clutter.Vertex.Vertex
    type AttrTransferType ActorRotationCenterYPropertyInfo = Clutter.Vertex.Vertex
    type AttrGetType ActorRotationCenterYPropertyInfo = (Maybe Clutter.Vertex.Vertex)
    type AttrLabel ActorRotationCenterYPropertyInfo = "rotation-center-y"
    type AttrOrigin ActorRotationCenterYPropertyInfo = Actor
    attrGet = getActorRotationCenterY
    attrSet = setActorRotationCenterY
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorRotationCenterY
    attrClear = clearActorRotationCenterY
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.rotationCenterY"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:rotationCenterY"
        })
#endif

-- VVV Prop "rotation-center-z"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Vertex"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@rotation-center-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #rotationCenterZ
-- @
getActorRotationCenterZ :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Vertex.Vertex)
getActorRotationCenterZ :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Vertex)
getActorRotationCenterZ o
obj = IO (Maybe Vertex) -> m (Maybe Vertex)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Vertex) -> m (Maybe Vertex))
-> IO (Maybe Vertex) -> m (Maybe Vertex)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Vertex -> Vertex) -> IO (Maybe Vertex)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"rotation-center-z" ManagedPtr Vertex -> Vertex
Clutter.Vertex.Vertex

-- | Set the value of the “@rotation-center-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #rotationCenterZ 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorRotationCenterZ :: (MonadIO m, IsActor o) => o -> Clutter.Vertex.Vertex -> m ()
setActorRotationCenterZ :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Vertex -> m ()
setActorRotationCenterZ o
obj Vertex
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Vertex -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"rotation-center-z" (Vertex -> Maybe Vertex
forall a. a -> Maybe a
Just Vertex
val)

-- | Construct a `GValueConstruct` with valid value for the “@rotation-center-z@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorRotationCenterZ :: (IsActor o, MIO.MonadIO m) => Clutter.Vertex.Vertex -> m (GValueConstruct o)
constructActorRotationCenterZ :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Vertex -> m (GValueConstruct o)
constructActorRotationCenterZ Vertex
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Vertex -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"rotation-center-z" (Vertex -> Maybe Vertex
forall a. a -> Maybe a
P.Just Vertex
val)

-- | Set the value of the “@rotation-center-z@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #rotationCenterZ
-- @
clearActorRotationCenterZ :: (MonadIO m, IsActor o) => o -> m ()
clearActorRotationCenterZ :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorRotationCenterZ o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Vertex -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"rotation-center-z" (Maybe Vertex
forall a. Maybe a
Nothing :: Maybe Clutter.Vertex.Vertex)

#if defined(ENABLE_OVERLOADING)
data ActorRotationCenterZPropertyInfo
instance AttrInfo ActorRotationCenterZPropertyInfo where
    type AttrAllowedOps ActorRotationCenterZPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorRotationCenterZPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRotationCenterZPropertyInfo = (~) Clutter.Vertex.Vertex
    type AttrTransferTypeConstraint ActorRotationCenterZPropertyInfo = (~) Clutter.Vertex.Vertex
    type AttrTransferType ActorRotationCenterZPropertyInfo = Clutter.Vertex.Vertex
    type AttrGetType ActorRotationCenterZPropertyInfo = (Maybe Clutter.Vertex.Vertex)
    type AttrLabel ActorRotationCenterZPropertyInfo = "rotation-center-z"
    type AttrOrigin ActorRotationCenterZPropertyInfo = Actor
    attrGet = getActorRotationCenterZ
    attrSet = setActorRotationCenterZ
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorRotationCenterZ
    attrClear = clearActorRotationCenterZ
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.rotationCenterZ"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:rotationCenterZ"
        })
#endif

-- VVV Prop "rotation-center-z-gravity"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Gravity"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@rotation-center-z-gravity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #rotationCenterZGravity
-- @
getActorRotationCenterZGravity :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.Gravity
getActorRotationCenterZGravity :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Gravity
getActorRotationCenterZGravity o
obj = IO Gravity -> m Gravity
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Gravity -> m Gravity) -> IO Gravity -> m Gravity
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Gravity
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"rotation-center-z-gravity"

-- | Set the value of the “@rotation-center-z-gravity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #rotationCenterZGravity 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorRotationCenterZGravity :: (MonadIO m, IsActor o) => o -> Clutter.Enums.Gravity -> m ()
setActorRotationCenterZGravity :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Gravity -> m ()
setActorRotationCenterZGravity o
obj Gravity
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Gravity -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"rotation-center-z-gravity" Gravity
val

-- | Construct a `GValueConstruct` with valid value for the “@rotation-center-z-gravity@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorRotationCenterZGravity :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.Gravity -> m (GValueConstruct o)
constructActorRotationCenterZGravity :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Gravity -> m (GValueConstruct o)
constructActorRotationCenterZGravity Gravity
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Gravity -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"rotation-center-z-gravity" Gravity
val

#if defined(ENABLE_OVERLOADING)
data ActorRotationCenterZGravityPropertyInfo
instance AttrInfo ActorRotationCenterZGravityPropertyInfo where
    type AttrAllowedOps ActorRotationCenterZGravityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorRotationCenterZGravityPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorRotationCenterZGravityPropertyInfo = (~) Clutter.Enums.Gravity
    type AttrTransferTypeConstraint ActorRotationCenterZGravityPropertyInfo = (~) Clutter.Enums.Gravity
    type AttrTransferType ActorRotationCenterZGravityPropertyInfo = Clutter.Enums.Gravity
    type AttrGetType ActorRotationCenterZGravityPropertyInfo = Clutter.Enums.Gravity
    type AttrLabel ActorRotationCenterZGravityPropertyInfo = "rotation-center-z-gravity"
    type AttrOrigin ActorRotationCenterZGravityPropertyInfo = Actor
    attrGet = getActorRotationCenterZGravity
    attrSet = setActorRotationCenterZGravity
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorRotationCenterZGravity
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.rotationCenterZGravity"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:rotationCenterZGravity"
        })
#endif

-- VVV Prop "scale-center-x"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@scale-center-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #scaleCenterX
-- @
getActorScaleCenterX :: (MonadIO m, IsActor o) => o -> m Float
getActorScaleCenterX :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorScaleCenterX o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"scale-center-x"

-- | Set the value of the “@scale-center-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #scaleCenterX 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorScaleCenterX :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorScaleCenterX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorScaleCenterX o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"scale-center-x" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@scale-center-x@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorScaleCenterX :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorScaleCenterX :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorScaleCenterX Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"scale-center-x" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorScaleCenterXPropertyInfo
instance AttrInfo ActorScaleCenterXPropertyInfo where
    type AttrAllowedOps ActorScaleCenterXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorScaleCenterXPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorScaleCenterXPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorScaleCenterXPropertyInfo = (~) Float
    type AttrTransferType ActorScaleCenterXPropertyInfo = Float
    type AttrGetType ActorScaleCenterXPropertyInfo = Float
    type AttrLabel ActorScaleCenterXPropertyInfo = "scale-center-x"
    type AttrOrigin ActorScaleCenterXPropertyInfo = Actor
    attrGet = getActorScaleCenterX
    attrSet = setActorScaleCenterX
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorScaleCenterX
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.scaleCenterX"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:scaleCenterX"
        })
#endif

-- VVV Prop "scale-center-y"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@scale-center-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #scaleCenterY
-- @
getActorScaleCenterY :: (MonadIO m, IsActor o) => o -> m Float
getActorScaleCenterY :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorScaleCenterY o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"scale-center-y"

-- | Set the value of the “@scale-center-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #scaleCenterY 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorScaleCenterY :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorScaleCenterY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorScaleCenterY o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"scale-center-y" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@scale-center-y@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorScaleCenterY :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorScaleCenterY :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorScaleCenterY Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"scale-center-y" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorScaleCenterYPropertyInfo
instance AttrInfo ActorScaleCenterYPropertyInfo where
    type AttrAllowedOps ActorScaleCenterYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorScaleCenterYPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorScaleCenterYPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorScaleCenterYPropertyInfo = (~) Float
    type AttrTransferType ActorScaleCenterYPropertyInfo = Float
    type AttrGetType ActorScaleCenterYPropertyInfo = Float
    type AttrLabel ActorScaleCenterYPropertyInfo = "scale-center-y"
    type AttrOrigin ActorScaleCenterYPropertyInfo = Actor
    attrGet = getActorScaleCenterY
    attrSet = setActorScaleCenterY
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorScaleCenterY
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.scaleCenterY"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:scaleCenterY"
        })
#endif

-- VVV Prop "scale-gravity"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Gravity"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@scale-gravity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #scaleGravity
-- @
getActorScaleGravity :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.Gravity
getActorScaleGravity :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Gravity
getActorScaleGravity o
obj = IO Gravity -> m Gravity
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Gravity -> m Gravity) -> IO Gravity -> m Gravity
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Gravity
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"scale-gravity"

-- | Set the value of the “@scale-gravity@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #scaleGravity 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorScaleGravity :: (MonadIO m, IsActor o) => o -> Clutter.Enums.Gravity -> m ()
setActorScaleGravity :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Gravity -> m ()
setActorScaleGravity o
obj Gravity
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Gravity -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"scale-gravity" Gravity
val

-- | Construct a `GValueConstruct` with valid value for the “@scale-gravity@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorScaleGravity :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.Gravity -> m (GValueConstruct o)
constructActorScaleGravity :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Gravity -> m (GValueConstruct o)
constructActorScaleGravity Gravity
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Gravity -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"scale-gravity" Gravity
val

#if defined(ENABLE_OVERLOADING)
data ActorScaleGravityPropertyInfo
instance AttrInfo ActorScaleGravityPropertyInfo where
    type AttrAllowedOps ActorScaleGravityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorScaleGravityPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorScaleGravityPropertyInfo = (~) Clutter.Enums.Gravity
    type AttrTransferTypeConstraint ActorScaleGravityPropertyInfo = (~) Clutter.Enums.Gravity
    type AttrTransferType ActorScaleGravityPropertyInfo = Clutter.Enums.Gravity
    type AttrGetType ActorScaleGravityPropertyInfo = Clutter.Enums.Gravity
    type AttrLabel ActorScaleGravityPropertyInfo = "scale-gravity"
    type AttrOrigin ActorScaleGravityPropertyInfo = Actor
    attrGet = getActorScaleGravity
    attrSet = setActorScaleGravity
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorScaleGravity
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.scaleGravity"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:scaleGravity"
        })
#endif

-- VVV Prop "scale-x"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@scale-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #scaleX
-- @
getActorScaleX :: (MonadIO m, IsActor o) => o -> m Double
getActorScaleX :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Double
getActorScaleX o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"scale-x"

-- | Set the value of the “@scale-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #scaleX 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorScaleX :: (MonadIO m, IsActor o) => o -> Double -> m ()
setActorScaleX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Double -> m ()
setActorScaleX o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"scale-x" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@scale-x@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorScaleX :: (IsActor o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructActorScaleX :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructActorScaleX Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"scale-x" Double
val

#if defined(ENABLE_OVERLOADING)
data ActorScaleXPropertyInfo
instance AttrInfo ActorScaleXPropertyInfo where
    type AttrAllowedOps ActorScaleXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorScaleXPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorScaleXPropertyInfo = (~) Double
    type AttrTransferTypeConstraint ActorScaleXPropertyInfo = (~) Double
    type AttrTransferType ActorScaleXPropertyInfo = Double
    type AttrGetType ActorScaleXPropertyInfo = Double
    type AttrLabel ActorScaleXPropertyInfo = "scale-x"
    type AttrOrigin ActorScaleXPropertyInfo = Actor
    attrGet = getActorScaleX
    attrSet = setActorScaleX
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorScaleX
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.scaleX"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:scaleX"
        })
#endif

-- VVV Prop "scale-y"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@scale-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #scaleY
-- @
getActorScaleY :: (MonadIO m, IsActor o) => o -> m Double
getActorScaleY :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Double
getActorScaleY o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"scale-y"

-- | Set the value of the “@scale-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #scaleY 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorScaleY :: (MonadIO m, IsActor o) => o -> Double -> m ()
setActorScaleY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Double -> m ()
setActorScaleY o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"scale-y" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@scale-y@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorScaleY :: (IsActor o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructActorScaleY :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructActorScaleY Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"scale-y" Double
val

#if defined(ENABLE_OVERLOADING)
data ActorScaleYPropertyInfo
instance AttrInfo ActorScaleYPropertyInfo where
    type AttrAllowedOps ActorScaleYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorScaleYPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorScaleYPropertyInfo = (~) Double
    type AttrTransferTypeConstraint ActorScaleYPropertyInfo = (~) Double
    type AttrTransferType ActorScaleYPropertyInfo = Double
    type AttrGetType ActorScaleYPropertyInfo = Double
    type AttrLabel ActorScaleYPropertyInfo = "scale-y"
    type AttrOrigin ActorScaleYPropertyInfo = Actor
    attrGet = getActorScaleY
    attrSet = setActorScaleY
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorScaleY
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.scaleY"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:scaleY"
        })
#endif

-- VVV Prop "scale-z"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@scale-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #scaleZ
-- @
getActorScaleZ :: (MonadIO m, IsActor o) => o -> m Double
getActorScaleZ :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Double
getActorScaleZ o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"scale-z"

-- | Set the value of the “@scale-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #scaleZ 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorScaleZ :: (MonadIO m, IsActor o) => o -> Double -> m ()
setActorScaleZ :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Double -> m ()
setActorScaleZ o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"scale-z" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@scale-z@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorScaleZ :: (IsActor o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructActorScaleZ :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructActorScaleZ Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"scale-z" Double
val

#if defined(ENABLE_OVERLOADING)
data ActorScaleZPropertyInfo
instance AttrInfo ActorScaleZPropertyInfo where
    type AttrAllowedOps ActorScaleZPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorScaleZPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorScaleZPropertyInfo = (~) Double
    type AttrTransferTypeConstraint ActorScaleZPropertyInfo = (~) Double
    type AttrTransferType ActorScaleZPropertyInfo = Double
    type AttrGetType ActorScaleZPropertyInfo = Double
    type AttrLabel ActorScaleZPropertyInfo = "scale-z"
    type AttrOrigin ActorScaleZPropertyInfo = Actor
    attrGet = getActorScaleZ
    attrSet = setActorScaleZ
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorScaleZ
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.scaleZ"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:scaleZ"
        })
#endif

-- VVV Prop "show-on-set-parent"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@show-on-set-parent@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #showOnSetParent
-- @
getActorShowOnSetParent :: (MonadIO m, IsActor o) => o -> m Bool
getActorShowOnSetParent :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorShowOnSetParent o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"show-on-set-parent"

-- | Set the value of the “@show-on-set-parent@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #showOnSetParent 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorShowOnSetParent :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorShowOnSetParent :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorShowOnSetParent o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"show-on-set-parent" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-on-set-parent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorShowOnSetParent :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorShowOnSetParent :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorShowOnSetParent Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"show-on-set-parent" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorShowOnSetParentPropertyInfo
instance AttrInfo ActorShowOnSetParentPropertyInfo where
    type AttrAllowedOps ActorShowOnSetParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorShowOnSetParentPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorShowOnSetParentPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorShowOnSetParentPropertyInfo = (~) Bool
    type AttrTransferType ActorShowOnSetParentPropertyInfo = Bool
    type AttrGetType ActorShowOnSetParentPropertyInfo = Bool
    type AttrLabel ActorShowOnSetParentPropertyInfo = "show-on-set-parent"
    type AttrOrigin ActorShowOnSetParentPropertyInfo = Actor
    attrGet = getActorShowOnSetParent
    attrSet = setActorShowOnSetParent
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorShowOnSetParent
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.showOnSetParent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:showOnSetParent"
        })
#endif

-- VVV Prop "size"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Size"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #size
-- @
getActorSize :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Size.Size)
getActorSize :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Size)
getActorSize o
obj = IO (Maybe Size) -> m (Maybe Size)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Size) -> m (Maybe Size))
-> IO (Maybe Size) -> m (Maybe Size)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Size -> Size) -> IO (Maybe Size)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"size" ManagedPtr Size -> Size
Clutter.Size.Size

-- | Set the value of the “@size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #size 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorSize :: (MonadIO m, IsActor o) => o -> Clutter.Size.Size -> m ()
setActorSize :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Size -> m ()
setActorSize o
obj Size
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Size -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"size" (Size -> Maybe Size
forall a. a -> Maybe a
Just Size
val)

-- | Construct a `GValueConstruct` with valid value for the “@size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorSize :: (IsActor o, MIO.MonadIO m) => Clutter.Size.Size -> m (GValueConstruct o)
constructActorSize :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Size -> m (GValueConstruct o)
constructActorSize Size
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Size -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"size" (Size -> Maybe Size
forall a. a -> Maybe a
P.Just Size
val)

-- | Set the value of the “@size@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #size
-- @
clearActorSize :: (MonadIO m, IsActor o) => o -> m ()
clearActorSize :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorSize o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Size -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"size" (Maybe Size
forall a. Maybe a
Nothing :: Maybe Clutter.Size.Size)

#if defined(ENABLE_OVERLOADING)
data ActorSizePropertyInfo
instance AttrInfo ActorSizePropertyInfo where
    type AttrAllowedOps ActorSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorSizePropertyInfo = IsActor
    type AttrSetTypeConstraint ActorSizePropertyInfo = (~) Clutter.Size.Size
    type AttrTransferTypeConstraint ActorSizePropertyInfo = (~) Clutter.Size.Size
    type AttrTransferType ActorSizePropertyInfo = Clutter.Size.Size
    type AttrGetType ActorSizePropertyInfo = (Maybe Clutter.Size.Size)
    type AttrLabel ActorSizePropertyInfo = "size"
    type AttrOrigin ActorSizePropertyInfo = Actor
    attrGet = getActorSize
    attrSet = setActorSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorSize
    attrClear = clearActorSize
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.size"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:size"
        })
#endif

-- VVV Prop "text-direction"
   -- Type: TInterface (Name {namespace = "Clutter", name = "TextDirection"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@text-direction@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #textDirection
-- @
getActorTextDirection :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.TextDirection
getActorTextDirection :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m TextDirection
getActorTextDirection o
obj = IO TextDirection -> m TextDirection
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TextDirection -> m TextDirection)
-> IO TextDirection -> m TextDirection
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TextDirection
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"text-direction"

-- | Set the value of the “@text-direction@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #textDirection 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorTextDirection :: (MonadIO m, IsActor o) => o -> Clutter.Enums.TextDirection -> m ()
setActorTextDirection :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> TextDirection -> m ()
setActorTextDirection o
obj TextDirection
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> TextDirection -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"text-direction" TextDirection
val

-- | Construct a `GValueConstruct` with valid value for the “@text-direction@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorTextDirection :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.TextDirection -> m (GValueConstruct o)
constructActorTextDirection :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
TextDirection -> m (GValueConstruct o)
constructActorTextDirection TextDirection
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> TextDirection -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"text-direction" TextDirection
val

#if defined(ENABLE_OVERLOADING)
data ActorTextDirectionPropertyInfo
instance AttrInfo ActorTextDirectionPropertyInfo where
    type AttrAllowedOps ActorTextDirectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorTextDirectionPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorTextDirectionPropertyInfo = (~) Clutter.Enums.TextDirection
    type AttrTransferTypeConstraint ActorTextDirectionPropertyInfo = (~) Clutter.Enums.TextDirection
    type AttrTransferType ActorTextDirectionPropertyInfo = Clutter.Enums.TextDirection
    type AttrGetType ActorTextDirectionPropertyInfo = Clutter.Enums.TextDirection
    type AttrLabel ActorTextDirectionPropertyInfo = "text-direction"
    type AttrOrigin ActorTextDirectionPropertyInfo = Actor
    attrGet = getActorTextDirection
    attrSet = setActorTextDirection
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorTextDirection
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.textDirection"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:textDirection"
        })
#endif

-- VVV Prop "transform"
   -- Type: TInterface (Name {namespace = "Clutter", name = "Matrix"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@transform@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #transform
-- @
getActorTransform :: (MonadIO m, IsActor o) => o -> m (Maybe Clutter.Matrix.Matrix)
getActorTransform :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> m (Maybe Matrix)
getActorTransform o
obj = IO (Maybe Matrix) -> m (Maybe Matrix)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Matrix) -> m (Maybe Matrix))
-> IO (Maybe Matrix) -> m (Maybe Matrix)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Matrix -> Matrix) -> IO (Maybe Matrix)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"transform" ManagedPtr Matrix -> Matrix
Clutter.Matrix.Matrix

-- | Set the value of the “@transform@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #transform 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorTransform :: (MonadIO m, IsActor o) => o -> Clutter.Matrix.Matrix -> m ()
setActorTransform :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Matrix -> m ()
setActorTransform o
obj Matrix
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Matrix -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"transform" (Matrix -> Maybe Matrix
forall a. a -> Maybe a
Just Matrix
val)

-- | Construct a `GValueConstruct` with valid value for the “@transform@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorTransform :: (IsActor o, MIO.MonadIO m) => Clutter.Matrix.Matrix -> m (GValueConstruct o)
constructActorTransform :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Matrix -> m (GValueConstruct o)
constructActorTransform Matrix
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Matrix -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"transform" (Matrix -> Maybe Matrix
forall a. a -> Maybe a
P.Just Matrix
val)

-- | Set the value of the “@transform@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #transform
-- @
clearActorTransform :: (MonadIO m, IsActor o) => o -> m ()
clearActorTransform :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ()
clearActorTransform o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Matrix -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"transform" (Maybe Matrix
forall a. Maybe a
Nothing :: Maybe Clutter.Matrix.Matrix)

#if defined(ENABLE_OVERLOADING)
data ActorTransformPropertyInfo
instance AttrInfo ActorTransformPropertyInfo where
    type AttrAllowedOps ActorTransformPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActorTransformPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorTransformPropertyInfo = (~) Clutter.Matrix.Matrix
    type AttrTransferTypeConstraint ActorTransformPropertyInfo = (~) Clutter.Matrix.Matrix
    type AttrTransferType ActorTransformPropertyInfo = Clutter.Matrix.Matrix
    type AttrGetType ActorTransformPropertyInfo = (Maybe Clutter.Matrix.Matrix)
    type AttrLabel ActorTransformPropertyInfo = "transform"
    type AttrOrigin ActorTransformPropertyInfo = Actor
    attrGet = getActorTransform
    attrSet = setActorTransform
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorTransform
    attrClear = clearActorTransform
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.transform"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:transform"
        })
#endif

-- VVV Prop "transform-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@transform-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #transformSet
-- @
getActorTransformSet :: (MonadIO m, IsActor o) => o -> m Bool
getActorTransformSet :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorTransformSet o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"transform-set"

#if defined(ENABLE_OVERLOADING)
data ActorTransformSetPropertyInfo
instance AttrInfo ActorTransformSetPropertyInfo where
    type AttrAllowedOps ActorTransformSetPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ActorTransformSetPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorTransformSetPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ActorTransformSetPropertyInfo = (~) ()
    type AttrTransferType ActorTransformSetPropertyInfo = ()
    type AttrGetType ActorTransformSetPropertyInfo = Bool
    type AttrLabel ActorTransformSetPropertyInfo = "transform-set"
    type AttrOrigin ActorTransformSetPropertyInfo = Actor
    attrGet = getActorTransformSet
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.transformSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:transformSet"
        })
#endif

-- VVV Prop "translation-x"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@translation-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #translationX
-- @
getActorTranslationX :: (MonadIO m, IsActor o) => o -> m Float
getActorTranslationX :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorTranslationX o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"translation-x"

-- | Set the value of the “@translation-x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #translationX 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorTranslationX :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorTranslationX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorTranslationX o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"translation-x" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@translation-x@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorTranslationX :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorTranslationX :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorTranslationX Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"translation-x" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorTranslationXPropertyInfo
instance AttrInfo ActorTranslationXPropertyInfo where
    type AttrAllowedOps ActorTranslationXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorTranslationXPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorTranslationXPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorTranslationXPropertyInfo = (~) Float
    type AttrTransferType ActorTranslationXPropertyInfo = Float
    type AttrGetType ActorTranslationXPropertyInfo = Float
    type AttrLabel ActorTranslationXPropertyInfo = "translation-x"
    type AttrOrigin ActorTranslationXPropertyInfo = Actor
    attrGet = getActorTranslationX
    attrSet = setActorTranslationX
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorTranslationX
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.translationX"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:translationX"
        })
#endif

-- VVV Prop "translation-y"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@translation-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #translationY
-- @
getActorTranslationY :: (MonadIO m, IsActor o) => o -> m Float
getActorTranslationY :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorTranslationY o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"translation-y"

-- | Set the value of the “@translation-y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #translationY 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorTranslationY :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorTranslationY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorTranslationY o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"translation-y" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@translation-y@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorTranslationY :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorTranslationY :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorTranslationY Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"translation-y" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorTranslationYPropertyInfo
instance AttrInfo ActorTranslationYPropertyInfo where
    type AttrAllowedOps ActorTranslationYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorTranslationYPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorTranslationYPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorTranslationYPropertyInfo = (~) Float
    type AttrTransferType ActorTranslationYPropertyInfo = Float
    type AttrGetType ActorTranslationYPropertyInfo = Float
    type AttrLabel ActorTranslationYPropertyInfo = "translation-y"
    type AttrOrigin ActorTranslationYPropertyInfo = Actor
    attrGet = getActorTranslationY
    attrSet = setActorTranslationY
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorTranslationY
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.translationY"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:translationY"
        })
#endif

-- VVV Prop "translation-z"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@translation-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #translationZ
-- @
getActorTranslationZ :: (MonadIO m, IsActor o) => o -> m Float
getActorTranslationZ :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorTranslationZ o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"translation-z"

-- | Set the value of the “@translation-z@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #translationZ 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorTranslationZ :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorTranslationZ :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorTranslationZ o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"translation-z" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@translation-z@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorTranslationZ :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorTranslationZ :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorTranslationZ Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"translation-z" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorTranslationZPropertyInfo
instance AttrInfo ActorTranslationZPropertyInfo where
    type AttrAllowedOps ActorTranslationZPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorTranslationZPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorTranslationZPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorTranslationZPropertyInfo = (~) Float
    type AttrTransferType ActorTranslationZPropertyInfo = Float
    type AttrGetType ActorTranslationZPropertyInfo = Float
    type AttrLabel ActorTranslationZPropertyInfo = "translation-z"
    type AttrOrigin ActorTranslationZPropertyInfo = Actor
    attrGet = getActorTranslationZ
    attrSet = setActorTranslationZ
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorTranslationZ
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.translationZ"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:translationZ"
        })
#endif

-- VVV Prop "visible"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #visible
-- @
getActorVisible :: (MonadIO m, IsActor o) => o -> m Bool
getActorVisible :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorVisible o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"visible"

-- | Set the value of the “@visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #visible 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorVisible :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorVisible :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorVisible o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"visible" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorVisible :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorVisible :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorVisible Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"visible" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorVisiblePropertyInfo
instance AttrInfo ActorVisiblePropertyInfo where
    type AttrAllowedOps ActorVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorVisiblePropertyInfo = IsActor
    type AttrSetTypeConstraint ActorVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorVisiblePropertyInfo = (~) Bool
    type AttrTransferType ActorVisiblePropertyInfo = Bool
    type AttrGetType ActorVisiblePropertyInfo = Bool
    type AttrLabel ActorVisiblePropertyInfo = "visible"
    type AttrOrigin ActorVisiblePropertyInfo = Actor
    attrGet = getActorVisible
    attrSet = setActorVisible
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorVisible
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.visible"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:visible"
        })
#endif

-- VVV Prop "width"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #width
-- @
getActorWidth :: (MonadIO m, IsActor o) => o -> m Float
getActorWidth :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorWidth o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"width"

-- | Set the value of the “@width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #width 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorWidth :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorWidth :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorWidth o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"width" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorWidth :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorWidth :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorWidth Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"width" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorWidthPropertyInfo
instance AttrInfo ActorWidthPropertyInfo where
    type AttrAllowedOps ActorWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorWidthPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorWidthPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorWidthPropertyInfo = (~) Float
    type AttrTransferType ActorWidthPropertyInfo = Float
    type AttrGetType ActorWidthPropertyInfo = Float
    type AttrLabel ActorWidthPropertyInfo = "width"
    type AttrOrigin ActorWidthPropertyInfo = Actor
    attrGet = getActorWidth
    attrSet = setActorWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.width"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:width"
        })
#endif

-- VVV Prop "x"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #x
-- @
getActorX :: (MonadIO m, IsActor o) => o -> m Float
getActorX :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorX o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"x"

-- | Set the value of the “@x@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #x 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorX :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorX :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorX o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"x" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@x@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorX :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorX :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorX Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"x" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorXPropertyInfo
instance AttrInfo ActorXPropertyInfo where
    type AttrAllowedOps ActorXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorXPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorXPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorXPropertyInfo = (~) Float
    type AttrTransferType ActorXPropertyInfo = Float
    type AttrGetType ActorXPropertyInfo = Float
    type AttrLabel ActorXPropertyInfo = "x"
    type AttrOrigin ActorXPropertyInfo = Actor
    attrGet = getActorX
    attrSet = setActorX
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorX
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.x"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:x"
        })
#endif

-- VVV Prop "x-align"
   -- Type: TInterface (Name {namespace = "Clutter", name = "ActorAlign"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@x-align@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #xAlign
-- @
getActorXAlign :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.ActorAlign
getActorXAlign :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ActorAlign
getActorXAlign o
obj = IO ActorAlign -> m ActorAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ActorAlign -> m ActorAlign) -> IO ActorAlign -> m ActorAlign
forall a b. (a -> b) -> a -> b
$ o -> String -> IO ActorAlign
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"x-align"

-- | Set the value of the “@x-align@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #xAlign 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorXAlign :: (MonadIO m, IsActor o) => o -> Clutter.Enums.ActorAlign -> m ()
setActorXAlign :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> ActorAlign -> m ()
setActorXAlign o
obj ActorAlign
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ActorAlign -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"x-align" ActorAlign
val

-- | Construct a `GValueConstruct` with valid value for the “@x-align@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorXAlign :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.ActorAlign -> m (GValueConstruct o)
constructActorXAlign :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
ActorAlign -> m (GValueConstruct o)
constructActorXAlign ActorAlign
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> ActorAlign -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"x-align" ActorAlign
val

#if defined(ENABLE_OVERLOADING)
data ActorXAlignPropertyInfo
instance AttrInfo ActorXAlignPropertyInfo where
    type AttrAllowedOps ActorXAlignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorXAlignPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorXAlignPropertyInfo = (~) Clutter.Enums.ActorAlign
    type AttrTransferTypeConstraint ActorXAlignPropertyInfo = (~) Clutter.Enums.ActorAlign
    type AttrTransferType ActorXAlignPropertyInfo = Clutter.Enums.ActorAlign
    type AttrGetType ActorXAlignPropertyInfo = Clutter.Enums.ActorAlign
    type AttrLabel ActorXAlignPropertyInfo = "x-align"
    type AttrOrigin ActorXAlignPropertyInfo = Actor
    attrGet = getActorXAlign
    attrSet = setActorXAlign
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorXAlign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.xAlign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:xAlign"
        })
#endif

-- VVV Prop "x-expand"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@x-expand@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #xExpand
-- @
getActorXExpand :: (MonadIO m, IsActor o) => o -> m Bool
getActorXExpand :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorXExpand o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"x-expand"

-- | Set the value of the “@x-expand@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #xExpand 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorXExpand :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorXExpand :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorXExpand o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"x-expand" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@x-expand@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorXExpand :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorXExpand :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorXExpand Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"x-expand" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorXExpandPropertyInfo
instance AttrInfo ActorXExpandPropertyInfo where
    type AttrAllowedOps ActorXExpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorXExpandPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorXExpandPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorXExpandPropertyInfo = (~) Bool
    type AttrTransferType ActorXExpandPropertyInfo = Bool
    type AttrGetType ActorXExpandPropertyInfo = Bool
    type AttrLabel ActorXExpandPropertyInfo = "x-expand"
    type AttrOrigin ActorXExpandPropertyInfo = Actor
    attrGet = getActorXExpand
    attrSet = setActorXExpand
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorXExpand
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.xExpand"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:xExpand"
        })
#endif

-- VVV Prop "y"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #y
-- @
getActorY :: (MonadIO m, IsActor o) => o -> m Float
getActorY :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorY o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"y"

-- | Set the value of the “@y@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #y 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorY :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorY :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorY o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"y" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@y@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorY :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorY :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorY Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"y" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorYPropertyInfo
instance AttrInfo ActorYPropertyInfo where
    type AttrAllowedOps ActorYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorYPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorYPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorYPropertyInfo = (~) Float
    type AttrTransferType ActorYPropertyInfo = Float
    type AttrGetType ActorYPropertyInfo = Float
    type AttrLabel ActorYPropertyInfo = "y"
    type AttrOrigin ActorYPropertyInfo = Actor
    attrGet = getActorY
    attrSet = setActorY
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorY
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.y"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:y"
        })
#endif

-- VVV Prop "y-align"
   -- Type: TInterface (Name {namespace = "Clutter", name = "ActorAlign"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@y-align@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #yAlign
-- @
getActorYAlign :: (MonadIO m, IsActor o) => o -> m Clutter.Enums.ActorAlign
getActorYAlign :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m ActorAlign
getActorYAlign o
obj = IO ActorAlign -> m ActorAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ActorAlign -> m ActorAlign) -> IO ActorAlign -> m ActorAlign
forall a b. (a -> b) -> a -> b
$ o -> String -> IO ActorAlign
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"y-align"

-- | Set the value of the “@y-align@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #yAlign 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorYAlign :: (MonadIO m, IsActor o) => o -> Clutter.Enums.ActorAlign -> m ()
setActorYAlign :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> ActorAlign -> m ()
setActorYAlign o
obj ActorAlign
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ActorAlign -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"y-align" ActorAlign
val

-- | Construct a `GValueConstruct` with valid value for the “@y-align@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorYAlign :: (IsActor o, MIO.MonadIO m) => Clutter.Enums.ActorAlign -> m (GValueConstruct o)
constructActorYAlign :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
ActorAlign -> m (GValueConstruct o)
constructActorYAlign ActorAlign
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> ActorAlign -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"y-align" ActorAlign
val

#if defined(ENABLE_OVERLOADING)
data ActorYAlignPropertyInfo
instance AttrInfo ActorYAlignPropertyInfo where
    type AttrAllowedOps ActorYAlignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorYAlignPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorYAlignPropertyInfo = (~) Clutter.Enums.ActorAlign
    type AttrTransferTypeConstraint ActorYAlignPropertyInfo = (~) Clutter.Enums.ActorAlign
    type AttrTransferType ActorYAlignPropertyInfo = Clutter.Enums.ActorAlign
    type AttrGetType ActorYAlignPropertyInfo = Clutter.Enums.ActorAlign
    type AttrLabel ActorYAlignPropertyInfo = "y-align"
    type AttrOrigin ActorYAlignPropertyInfo = Actor
    attrGet = getActorYAlign
    attrSet = setActorYAlign
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorYAlign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.yAlign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:yAlign"
        })
#endif

-- VVV Prop "y-expand"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@y-expand@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #yExpand
-- @
getActorYExpand :: (MonadIO m, IsActor o) => o -> m Bool
getActorYExpand :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Bool
getActorYExpand o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"y-expand"

-- | Set the value of the “@y-expand@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #yExpand 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorYExpand :: (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorYExpand :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> Bool -> m ()
setActorYExpand o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"y-expand" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@y-expand@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorYExpand :: (IsActor o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructActorYExpand :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructActorYExpand Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"y-expand" Bool
val

#if defined(ENABLE_OVERLOADING)
data ActorYExpandPropertyInfo
instance AttrInfo ActorYExpandPropertyInfo where
    type AttrAllowedOps ActorYExpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorYExpandPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorYExpandPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ActorYExpandPropertyInfo = (~) Bool
    type AttrTransferType ActorYExpandPropertyInfo = Bool
    type AttrGetType ActorYExpandPropertyInfo = Bool
    type AttrLabel ActorYExpandPropertyInfo = "y-expand"
    type AttrOrigin ActorYExpandPropertyInfo = Actor
    attrGet = getActorYExpand
    attrSet = setActorYExpand
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorYExpand
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.yExpand"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:yExpand"
        })
#endif

-- VVV Prop "z-position"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@z-position@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actor #zPosition
-- @
getActorZPosition :: (MonadIO m, IsActor o) => o -> m Float
getActorZPosition :: forall (m :: * -> *) o. (MonadIO m, IsActor o) => o -> m Float
getActorZPosition o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"z-position"

-- | Set the value of the “@z-position@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actor [ #zPosition 'Data.GI.Base.Attributes.:=' value ]
-- @
setActorZPosition :: (MonadIO m, IsActor o) => o -> Float -> m ()
setActorZPosition :: forall (m :: * -> *) o.
(MonadIO m, IsActor o) =>
o -> Float -> m ()
setActorZPosition o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"z-position" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@z-position@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructActorZPosition :: (IsActor o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructActorZPosition :: forall o (m :: * -> *).
(IsActor o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructActorZPosition Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"z-position" Float
val

#if defined(ENABLE_OVERLOADING)
data ActorZPositionPropertyInfo
instance AttrInfo ActorZPositionPropertyInfo where
    type AttrAllowedOps ActorZPositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActorZPositionPropertyInfo = IsActor
    type AttrSetTypeConstraint ActorZPositionPropertyInfo = (~) Float
    type AttrTransferTypeConstraint ActorZPositionPropertyInfo = (~) Float
    type AttrTransferType ActorZPositionPropertyInfo = Float
    type AttrGetType ActorZPositionPropertyInfo = Float
    type AttrLabel ActorZPositionPropertyInfo = "z-position"
    type AttrOrigin ActorZPositionPropertyInfo = Actor
    attrGet = getActorZPosition
    attrSet = setActorZPosition
    attrTransfer _ v = do
        return v
    attrConstruct = constructActorZPosition
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.zPosition"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#g:attr:zPosition"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Actor
type instance O.AttributeList Actor = ActorAttributeList
type ActorAttributeList = ('[ '("actions", ActorActionsPropertyInfo), '("allocation", ActorAllocationPropertyInfo), '("anchorGravity", ActorAnchorGravityPropertyInfo), '("anchorX", ActorAnchorXPropertyInfo), '("anchorY", ActorAnchorYPropertyInfo), '("backgroundColor", ActorBackgroundColorPropertyInfo), '("backgroundColorSet", ActorBackgroundColorSetPropertyInfo), '("childTransform", ActorChildTransformPropertyInfo), '("childTransformSet", ActorChildTransformSetPropertyInfo), '("clip", ActorClipPropertyInfo), '("clipRect", ActorClipRectPropertyInfo), '("clipToAllocation", ActorClipToAllocationPropertyInfo), '("constraints", ActorConstraintsPropertyInfo), '("content", ActorContentPropertyInfo), '("contentBox", ActorContentBoxPropertyInfo), '("contentGravity", ActorContentGravityPropertyInfo), '("contentRepeat", ActorContentRepeatPropertyInfo), '("depth", ActorDepthPropertyInfo), '("effect", ActorEffectPropertyInfo), '("firstChild", ActorFirstChildPropertyInfo), '("fixedPositionSet", ActorFixedPositionSetPropertyInfo), '("fixedX", ActorFixedXPropertyInfo), '("fixedY", ActorFixedYPropertyInfo), '("hasClip", ActorHasClipPropertyInfo), '("hasPointer", ActorHasPointerPropertyInfo), '("height", ActorHeightPropertyInfo), '("lastChild", ActorLastChildPropertyInfo), '("layoutManager", ActorLayoutManagerPropertyInfo), '("magnificationFilter", ActorMagnificationFilterPropertyInfo), '("mapped", ActorMappedPropertyInfo), '("marginBottom", ActorMarginBottomPropertyInfo), '("marginLeft", ActorMarginLeftPropertyInfo), '("marginRight", ActorMarginRightPropertyInfo), '("marginTop", ActorMarginTopPropertyInfo), '("minHeight", ActorMinHeightPropertyInfo), '("minHeightSet", ActorMinHeightSetPropertyInfo), '("minWidth", ActorMinWidthPropertyInfo), '("minWidthSet", ActorMinWidthSetPropertyInfo), '("minificationFilter", ActorMinificationFilterPropertyInfo), '("name", ActorNamePropertyInfo), '("naturalHeight", ActorNaturalHeightPropertyInfo), '("naturalHeightSet", ActorNaturalHeightSetPropertyInfo), '("naturalWidth", ActorNaturalWidthPropertyInfo), '("naturalWidthSet", ActorNaturalWidthSetPropertyInfo), '("offscreenRedirect", ActorOffscreenRedirectPropertyInfo), '("opacity", ActorOpacityPropertyInfo), '("pivotPoint", ActorPivotPointPropertyInfo), '("pivotPointZ", ActorPivotPointZPropertyInfo), '("position", ActorPositionPropertyInfo), '("reactive", ActorReactivePropertyInfo), '("realized", ActorRealizedPropertyInfo), '("requestMode", ActorRequestModePropertyInfo), '("rotationAngleX", ActorRotationAngleXPropertyInfo), '("rotationAngleY", ActorRotationAngleYPropertyInfo), '("rotationAngleZ", ActorRotationAngleZPropertyInfo), '("rotationCenterX", ActorRotationCenterXPropertyInfo), '("rotationCenterY", ActorRotationCenterYPropertyInfo), '("rotationCenterZ", ActorRotationCenterZPropertyInfo), '("rotationCenterZGravity", ActorRotationCenterZGravityPropertyInfo), '("scaleCenterX", ActorScaleCenterXPropertyInfo), '("scaleCenterY", ActorScaleCenterYPropertyInfo), '("scaleGravity", ActorScaleGravityPropertyInfo), '("scaleX", ActorScaleXPropertyInfo), '("scaleY", ActorScaleYPropertyInfo), '("scaleZ", ActorScaleZPropertyInfo), '("showOnSetParent", ActorShowOnSetParentPropertyInfo), '("size", ActorSizePropertyInfo), '("textDirection", ActorTextDirectionPropertyInfo), '("transform", ActorTransformPropertyInfo), '("transformSet", ActorTransformSetPropertyInfo), '("translationX", ActorTranslationXPropertyInfo), '("translationY", ActorTranslationYPropertyInfo), '("translationZ", ActorTranslationZPropertyInfo), '("visible", ActorVisiblePropertyInfo), '("width", ActorWidthPropertyInfo), '("x", ActorXPropertyInfo), '("xAlign", ActorXAlignPropertyInfo), '("xExpand", ActorXExpandPropertyInfo), '("y", ActorYPropertyInfo), '("yAlign", ActorYAlignPropertyInfo), '("yExpand", ActorYExpandPropertyInfo), '("zPosition", ActorZPositionPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
actorActions :: AttrLabelProxy "actions"
actorActions = AttrLabelProxy

actorAllocation :: AttrLabelProxy "allocation"
actorAllocation = AttrLabelProxy

actorAnchorGravity :: AttrLabelProxy "anchorGravity"
actorAnchorGravity = AttrLabelProxy

actorAnchorX :: AttrLabelProxy "anchorX"
actorAnchorX = AttrLabelProxy

actorAnchorY :: AttrLabelProxy "anchorY"
actorAnchorY = AttrLabelProxy

actorBackgroundColor :: AttrLabelProxy "backgroundColor"
actorBackgroundColor = AttrLabelProxy

actorBackgroundColorSet :: AttrLabelProxy "backgroundColorSet"
actorBackgroundColorSet = AttrLabelProxy

actorChildTransform :: AttrLabelProxy "childTransform"
actorChildTransform = AttrLabelProxy

actorChildTransformSet :: AttrLabelProxy "childTransformSet"
actorChildTransformSet = AttrLabelProxy

actorClip :: AttrLabelProxy "clip"
actorClip = AttrLabelProxy

actorClipRect :: AttrLabelProxy "clipRect"
actorClipRect = AttrLabelProxy

actorClipToAllocation :: AttrLabelProxy "clipToAllocation"
actorClipToAllocation = AttrLabelProxy

actorConstraints :: AttrLabelProxy "constraints"
actorConstraints = AttrLabelProxy

actorContent :: AttrLabelProxy "content"
actorContent = AttrLabelProxy

actorContentBox :: AttrLabelProxy "contentBox"
actorContentBox = AttrLabelProxy

actorContentGravity :: AttrLabelProxy "contentGravity"
actorContentGravity = AttrLabelProxy

actorContentRepeat :: AttrLabelProxy "contentRepeat"
actorContentRepeat = AttrLabelProxy

actorDepth :: AttrLabelProxy "depth"
actorDepth = AttrLabelProxy

actorEffect :: AttrLabelProxy "effect"
actorEffect = AttrLabelProxy

actorFirstChild :: AttrLabelProxy "firstChild"
actorFirstChild = AttrLabelProxy

actorFixedPositionSet :: AttrLabelProxy "fixedPositionSet"
actorFixedPositionSet = AttrLabelProxy

actorFixedX :: AttrLabelProxy "fixedX"
actorFixedX = AttrLabelProxy

actorFixedY :: AttrLabelProxy "fixedY"
actorFixedY = AttrLabelProxy

actorHeight :: AttrLabelProxy "height"
actorHeight = AttrLabelProxy

actorLastChild :: AttrLabelProxy "lastChild"
actorLastChild = AttrLabelProxy

actorLayoutManager :: AttrLabelProxy "layoutManager"
actorLayoutManager = AttrLabelProxy

actorMagnificationFilter :: AttrLabelProxy "magnificationFilter"
actorMagnificationFilter = AttrLabelProxy

actorMapped :: AttrLabelProxy "mapped"
actorMapped = AttrLabelProxy

actorMarginBottom :: AttrLabelProxy "marginBottom"
actorMarginBottom = AttrLabelProxy

actorMarginLeft :: AttrLabelProxy "marginLeft"
actorMarginLeft = AttrLabelProxy

actorMarginRight :: AttrLabelProxy "marginRight"
actorMarginRight = AttrLabelProxy

actorMarginTop :: AttrLabelProxy "marginTop"
actorMarginTop = AttrLabelProxy

actorMinHeight :: AttrLabelProxy "minHeight"
actorMinHeight = AttrLabelProxy

actorMinHeightSet :: AttrLabelProxy "minHeightSet"
actorMinHeightSet = AttrLabelProxy

actorMinWidth :: AttrLabelProxy "minWidth"
actorMinWidth = AttrLabelProxy

actorMinWidthSet :: AttrLabelProxy "minWidthSet"
actorMinWidthSet = AttrLabelProxy

actorMinificationFilter :: AttrLabelProxy "minificationFilter"
actorMinificationFilter = AttrLabelProxy

actorName :: AttrLabelProxy "name"
actorName = AttrLabelProxy

actorNaturalHeight :: AttrLabelProxy "naturalHeight"
actorNaturalHeight = AttrLabelProxy

actorNaturalHeightSet :: AttrLabelProxy "naturalHeightSet"
actorNaturalHeightSet = AttrLabelProxy

actorNaturalWidth :: AttrLabelProxy "naturalWidth"
actorNaturalWidth = AttrLabelProxy

actorNaturalWidthSet :: AttrLabelProxy "naturalWidthSet"
actorNaturalWidthSet = AttrLabelProxy

actorOffscreenRedirect :: AttrLabelProxy "offscreenRedirect"
actorOffscreenRedirect = AttrLabelProxy

actorOpacity :: AttrLabelProxy "opacity"
actorOpacity = AttrLabelProxy

actorPivotPoint :: AttrLabelProxy "pivotPoint"
actorPivotPoint = AttrLabelProxy

actorPivotPointZ :: AttrLabelProxy "pivotPointZ"
actorPivotPointZ = AttrLabelProxy

actorPosition :: AttrLabelProxy "position"
actorPosition = AttrLabelProxy

actorReactive :: AttrLabelProxy "reactive"
actorReactive = AttrLabelProxy

actorRealized :: AttrLabelProxy "realized"
actorRealized = AttrLabelProxy

actorRequestMode :: AttrLabelProxy "requestMode"
actorRequestMode = AttrLabelProxy

actorRotationAngleX :: AttrLabelProxy "rotationAngleX"
actorRotationAngleX = AttrLabelProxy

actorRotationAngleY :: AttrLabelProxy "rotationAngleY"
actorRotationAngleY = AttrLabelProxy

actorRotationAngleZ :: AttrLabelProxy "rotationAngleZ"
actorRotationAngleZ = AttrLabelProxy

actorRotationCenterX :: AttrLabelProxy "rotationCenterX"
actorRotationCenterX = AttrLabelProxy

actorRotationCenterY :: AttrLabelProxy "rotationCenterY"
actorRotationCenterY = AttrLabelProxy

actorRotationCenterZ :: AttrLabelProxy "rotationCenterZ"
actorRotationCenterZ = AttrLabelProxy

actorRotationCenterZGravity :: AttrLabelProxy "rotationCenterZGravity"
actorRotationCenterZGravity = AttrLabelProxy

actorScaleCenterX :: AttrLabelProxy "scaleCenterX"
actorScaleCenterX = AttrLabelProxy

actorScaleCenterY :: AttrLabelProxy "scaleCenterY"
actorScaleCenterY = AttrLabelProxy

actorScaleGravity :: AttrLabelProxy "scaleGravity"
actorScaleGravity = AttrLabelProxy

actorScaleX :: AttrLabelProxy "scaleX"
actorScaleX = AttrLabelProxy

actorScaleY :: AttrLabelProxy "scaleY"
actorScaleY = AttrLabelProxy

actorScaleZ :: AttrLabelProxy "scaleZ"
actorScaleZ = AttrLabelProxy

actorShowOnSetParent :: AttrLabelProxy "showOnSetParent"
actorShowOnSetParent = AttrLabelProxy

actorSize :: AttrLabelProxy "size"
actorSize = AttrLabelProxy

actorTextDirection :: AttrLabelProxy "textDirection"
actorTextDirection = AttrLabelProxy

actorTransform :: AttrLabelProxy "transform"
actorTransform = AttrLabelProxy

actorTransformSet :: AttrLabelProxy "transformSet"
actorTransformSet = AttrLabelProxy

actorTranslationX :: AttrLabelProxy "translationX"
actorTranslationX = AttrLabelProxy

actorTranslationY :: AttrLabelProxy "translationY"
actorTranslationY = AttrLabelProxy

actorTranslationZ :: AttrLabelProxy "translationZ"
actorTranslationZ = AttrLabelProxy

actorVisible :: AttrLabelProxy "visible"
actorVisible = AttrLabelProxy

actorWidth :: AttrLabelProxy "width"
actorWidth = AttrLabelProxy

actorX :: AttrLabelProxy "x"
actorX = AttrLabelProxy

actorXAlign :: AttrLabelProxy "xAlign"
actorXAlign = AttrLabelProxy

actorXExpand :: AttrLabelProxy "xExpand"
actorXExpand = AttrLabelProxy

actorY :: AttrLabelProxy "y"
actorY = AttrLabelProxy

actorYAlign :: AttrLabelProxy "yAlign"
actorYAlign = AttrLabelProxy

actorYExpand :: AttrLabelProxy "yExpand"
actorYExpand = AttrLabelProxy

actorZPosition :: AttrLabelProxy "zPosition"
actorZPosition = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Actor = ActorSignalList
type ActorSignalList = ('[ '("actorAdded", Clutter.Container.ContainerActorAddedSignalInfo), '("actorRemoved", Clutter.Container.ContainerActorRemovedSignalInfo), '("allocationChanged", ActorAllocationChangedSignalInfo), '("buttonPressEvent", ActorButtonPressEventSignalInfo), '("buttonReleaseEvent", ActorButtonReleaseEventSignalInfo), '("capturedEvent", ActorCapturedEventSignalInfo), '("childNotify", Clutter.Container.ContainerChildNotifySignalInfo), '("destroy", ActorDestroySignalInfo), '("enterEvent", ActorEnterEventSignalInfo), '("event", ActorEventSignalInfo), '("hide", ActorHideSignalInfo), '("keyFocusIn", ActorKeyFocusInSignalInfo), '("keyFocusOut", ActorKeyFocusOutSignalInfo), '("keyPressEvent", ActorKeyPressEventSignalInfo), '("keyReleaseEvent", ActorKeyReleaseEventSignalInfo), '("leaveEvent", ActorLeaveEventSignalInfo), '("motionEvent", ActorMotionEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paint", ActorPaintSignalInfo), '("parentSet", ActorParentSetSignalInfo), '("pick", ActorPickSignalInfo), '("queueRedraw", ActorQueueRedrawSignalInfo), '("queueRelayout", ActorQueueRelayoutSignalInfo), '("realize", ActorRealizeSignalInfo), '("scrollEvent", ActorScrollEventSignalInfo), '("show", ActorShowSignalInfo), '("touchEvent", ActorTouchEventSignalInfo), '("transitionStopped", ActorTransitionStoppedSignalInfo), '("transitionsCompleted", ActorTransitionsCompletedSignalInfo), '("unrealize", ActorUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method Actor::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_new" clutter_actor_new :: 
    IO (Ptr Actor)

-- | Creates a new t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- A newly created actor has a floating reference, which will be sunk
-- when it is added to another actor.
-- 
-- /Since: 1.10/
actorNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Actor
    -- ^ __Returns:__ the newly created t'GI.Clutter.Objects.Actor.Actor'
actorNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Actor
actorNew  = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
result <- IO (Ptr Actor)
clutter_actor_new
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorNew" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
result
    Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Actor::add_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Action" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterAction" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_add_action" clutter_actor_add_action :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Action.Action ->            -- action : TInterface (Name {namespace = "Clutter", name = "Action"})
    IO ()

-- | Adds /@action@/ to the list of actions applied to /@self@/
-- 
-- A t'GI.Clutter.Objects.Action.Action' can only belong to one actor at a time
-- 
-- The t'GI.Clutter.Objects.Actor.Actor' will hold a reference on /@action@/ until either
-- 'GI.Clutter.Objects.Actor.actorRemoveAction' or 'GI.Clutter.Objects.Actor.actorClearActions'
-- is called
-- 
-- /Since: 1.4/
actorAddAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Action.IsAction b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@action@/: a t'GI.Clutter.Objects.Action.Action'
    -> m ()
actorAddAction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsAction b) =>
a -> b -> m ()
actorAddAction a
self b
action = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Action
action' <- b -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
action
    Ptr Actor -> Ptr Action -> IO ()
clutter_actor_add_action Ptr Actor
self' Ptr Action
action'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
action
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAddActionMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, Clutter.Action.IsAction b) => O.OverloadedMethod ActorAddActionMethodInfo a signature where
    overloadedMethod = actorAddAction

instance O.OverloadedMethodInfo ActorAddActionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAddAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAddAction"
        })


#endif

-- method Actor::add_action_with_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name to set on the action"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Action" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterAction" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_add_action_with_name" clutter_actor_add_action_with_name :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Clutter.Action.Action ->            -- action : TInterface (Name {namespace = "Clutter", name = "Action"})
    IO ()

-- | A convenience function for setting the name of a t'GI.Clutter.Objects.Action.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/
actorAddActionWithName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Action.IsAction b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name to set on the action
    -> b
    -- ^ /@action@/: a t'GI.Clutter.Objects.Action.Action'
    -> m ()
actorAddActionWithName :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsAction b) =>
a -> Text -> b -> m ()
actorAddActionWithName a
self Text
name b
action = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Action
action' <- b -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
action
    Ptr Actor -> CString -> Ptr Action -> IO ()
clutter_actor_add_action_with_name Ptr Actor
self' CString
name' Ptr Action
action'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
action
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAddActionWithNameMethodInfo
instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsActor a, Clutter.Action.IsAction b) => O.OverloadedMethod ActorAddActionWithNameMethodInfo a signature where
    overloadedMethod = actorAddActionWithName

instance O.OverloadedMethodInfo ActorAddActionWithNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAddActionWithName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAddActionWithName"
        })


#endif

-- method Actor::add_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_add_child" clutter_actor_add_child :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Adds /@child@/ to the children of /@self@/.
-- 
-- This function will acquire a reference on /@child@/ that will only
-- be released when calling 'GI.Clutter.Objects.Actor.actorRemoveChild'.
-- 
-- This function will take into consideration the [Actor:depth]("GI.Clutter.Objects.Actor#g:attr:depth")
-- of /@child@/, and will keep the list of children sorted.
-- 
-- This function will emit the [Container::actorAdded]("GI.Clutter.Interfaces.Container#g:signal:actorAdded") signal
-- on /@self@/.
-- 
-- /Since: 1.10/
actorAddChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@child@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorAddChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> b -> m ()
actorAddChild a
self b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
child' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_add_child Ptr Actor
self' Ptr Actor
child'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAddChildMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorAddChildMethodInfo a signature where
    overloadedMethod = actorAddChild

instance O.OverloadedMethodInfo ActorAddChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAddChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAddChild"
        })


#endif

-- method Actor::add_constraint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "constraint"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Constraint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterConstraint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_add_constraint" clutter_actor_add_constraint :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Constraint.Constraint ->    -- constraint : TInterface (Name {namespace = "Clutter", name = "Constraint"})
    IO ()

-- | Adds /@constraint@/ to the list of t'GI.Clutter.Objects.Constraint.Constraint's applied
-- to /@self@/
-- 
-- The t'GI.Clutter.Objects.Actor.Actor' will hold a reference on the /@constraint@/ until
-- either 'GI.Clutter.Objects.Actor.actorRemoveConstraint' or
-- 'GI.Clutter.Objects.Actor.actorClearConstraints' is called.
-- 
-- /Since: 1.4/
actorAddConstraint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Constraint.IsConstraint b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@constraint@/: a t'GI.Clutter.Objects.Constraint.Constraint'
    -> m ()
actorAddConstraint :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsConstraint b) =>
a -> b -> m ()
actorAddConstraint a
self b
constraint = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Constraint
constraint' <- b -> IO (Ptr Constraint)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
constraint
    Ptr Actor -> Ptr Constraint -> IO ()
clutter_actor_add_constraint Ptr Actor
self' Ptr Constraint
constraint'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
constraint
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAddConstraintMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, Clutter.Constraint.IsConstraint b) => O.OverloadedMethod ActorAddConstraintMethodInfo a signature where
    overloadedMethod = actorAddConstraint

instance O.OverloadedMethodInfo ActorAddConstraintMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAddConstraint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAddConstraint"
        })


#endif

-- method Actor::add_constraint_with_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name to set on the constraint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "constraint"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Constraint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterConstraint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_add_constraint_with_name" clutter_actor_add_constraint_with_name :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Clutter.Constraint.Constraint ->    -- constraint : TInterface (Name {namespace = "Clutter", name = "Constraint"})
    IO ()

-- | A convenience function for setting the name of a t'GI.Clutter.Objects.Constraint.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/
actorAddConstraintWithName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Constraint.IsConstraint b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name to set on the constraint
    -> b
    -- ^ /@constraint@/: a t'GI.Clutter.Objects.Constraint.Constraint'
    -> m ()
actorAddConstraintWithName :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsConstraint b) =>
a -> Text -> b -> m ()
actorAddConstraintWithName a
self Text
name b
constraint = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Constraint
constraint' <- b -> IO (Ptr Constraint)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
constraint
    Ptr Actor -> CString -> Ptr Constraint -> IO ()
clutter_actor_add_constraint_with_name Ptr Actor
self' CString
name' Ptr Constraint
constraint'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
constraint
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAddConstraintWithNameMethodInfo
instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsActor a, Clutter.Constraint.IsConstraint b) => O.OverloadedMethod ActorAddConstraintWithNameMethodInfo a signature where
    overloadedMethod = actorAddConstraintWithName

instance O.OverloadedMethodInfo ActorAddConstraintWithNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAddConstraintWithName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAddConstraintWithName"
        })


#endif

-- method Actor::add_effect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Effect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEffect" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_add_effect" clutter_actor_add_effect :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Effect.Effect ->            -- effect : TInterface (Name {namespace = "Clutter", name = "Effect"})
    IO ()

-- | Adds /@effect@/ to the list of t'GI.Clutter.Objects.Effect.Effect's applied to /@self@/
-- 
-- The t'GI.Clutter.Objects.Actor.Actor' will hold a reference on the /@effect@/ until either
-- 'GI.Clutter.Objects.Actor.actorRemoveEffect' or 'GI.Clutter.Objects.Actor.actorClearEffects' is
-- called.
-- 
-- Note that as t'GI.Clutter.Objects.Effect.Effect' is initially unowned,
-- 'GI.Clutter.Objects.Actor.actorAddEffect' will sink any floating reference on /@effect@/.
-- 
-- /Since: 1.4/
actorAddEffect ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Effect.IsEffect b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@effect@/: a t'GI.Clutter.Objects.Effect.Effect'
    -> m ()
actorAddEffect :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsEffect b) =>
a -> b -> m ()
actorAddEffect a
self b
effect = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Effect
effect' <- b -> IO (Ptr Effect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    Ptr Actor -> Ptr Effect -> IO ()
clutter_actor_add_effect Ptr Actor
self' Ptr Effect
effect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAddEffectMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, Clutter.Effect.IsEffect b) => O.OverloadedMethod ActorAddEffectMethodInfo a signature where
    overloadedMethod = actorAddEffect

instance O.OverloadedMethodInfo ActorAddEffectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAddEffect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAddEffect"
        })


#endif

-- method Actor::add_effect_with_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name to set on the effect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Effect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEffect" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_add_effect_with_name" clutter_actor_add_effect_with_name :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Clutter.Effect.Effect ->            -- effect : TInterface (Name {namespace = "Clutter", name = "Effect"})
    IO ()

-- | A convenience function for setting the name of a t'GI.Clutter.Objects.Effect.Effect'
-- while adding it to the list of effects applied to /@self@/.
-- 
-- Note that as t'GI.Clutter.Objects.Effect.Effect' is initially unowned,
-- 'GI.Clutter.Objects.Actor.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/
actorAddEffectWithName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Effect.IsEffect b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name to set on the effect
    -> b
    -- ^ /@effect@/: a t'GI.Clutter.Objects.Effect.Effect'
    -> m ()
actorAddEffectWithName :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsEffect b) =>
a -> Text -> b -> m ()
actorAddEffectWithName a
self Text
name b
effect = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Effect
effect' <- b -> IO (Ptr Effect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    Ptr Actor -> CString -> Ptr Effect -> IO ()
clutter_actor_add_effect_with_name Ptr Actor
self' CString
name' Ptr Effect
effect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAddEffectWithNameMethodInfo
instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsActor a, Clutter.Effect.IsEffect b) => O.OverloadedMethod ActorAddEffectWithNameMethodInfo a signature where
    overloadedMethod = actorAddEffectWithName

instance O.OverloadedMethodInfo ActorAddEffectWithNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAddEffectWithName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAddEffectWithName"
        })


#endif

-- method Actor::add_transition
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the transition to add"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "transition"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Transition" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterTransition to add"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_add_transition" clutter_actor_add_transition :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Clutter.Transition.Transition ->    -- transition : TInterface (Name {namespace = "Clutter", name = "Transition"})
    IO ()

-- | Adds a /@transition@/ to the t'GI.Clutter.Objects.Actor.Actor'\'s list of animations.
-- 
-- The /@name@/ string is a per-actor unique identifier of the /@transition@/: only
-- one t'GI.Clutter.Objects.Transition.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/
actorAddTransition ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Transition.IsTransition b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the transition to add
    -> b
    -- ^ /@transition@/: the t'GI.Clutter.Objects.Transition.Transition' to add
    -> m ()
actorAddTransition :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsTransition b) =>
a -> Text -> b -> m ()
actorAddTransition a
self Text
name b
transition = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Transition
transition' <- b -> IO (Ptr Transition)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
transition
    Ptr Actor -> CString -> Ptr Transition -> IO ()
clutter_actor_add_transition Ptr Actor
self' CString
name' Ptr Transition
transition'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
transition
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAddTransitionMethodInfo
instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsActor a, Clutter.Transition.IsTransition b) => O.OverloadedMethod ActorAddTransitionMethodInfo a signature where
    overloadedMethod = actorAddTransition

instance O.OverloadedMethodInfo ActorAddTransitionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAddTransition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAddTransition"
        })


#endif

-- method Actor::allocate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorBox" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "new allocation of the actor, in parent-relative coordinates"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "AllocationFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags that control the allocation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_allocate" clutter_actor_allocate :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.ActorBox.ActorBox ->        -- box : TInterface (Name {namespace = "Clutter", name = "ActorBox"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "AllocationFlags"})
    IO ()

-- | Assigns the size of a t'GI.Clutter.Objects.Actor.Actor' from the given /@box@/.
-- 
-- This function should only be called on the children of an actor when
-- overriding the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/allocate/@() virtual function.
-- 
-- This function will adjust the stored allocation to take into account
-- the alignment flags set in the [Actor:xAlign]("GI.Clutter.Objects.Actor#g:attr:xAlign") and
-- [Actor:yAlign]("GI.Clutter.Objects.Actor#g:attr:yAlign") properties, as well as the margin values set in
-- the [Actor:marginTop]("GI.Clutter.Objects.Actor#g:attr:marginTop"), [Actor:marginRight]("GI.Clutter.Objects.Actor#g:attr:marginRight"),
-- [Actor:marginBottom]("GI.Clutter.Objects.Actor#g:attr:marginBottom"), and [Actor:marginLeft]("GI.Clutter.Objects.Actor#g:attr:marginLeft") properties.
-- 
-- This function will respect the easing state of the t'GI.Clutter.Objects.Actor.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/
actorAllocate ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.ActorBox.ActorBox
    -- ^ /@box@/: new allocation of the actor, in parent-relative coordinates
    -> [Clutter.Flags.AllocationFlags]
    -- ^ /@flags@/: flags that control the allocation
    -> m ()
actorAllocate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> ActorBox -> [AllocationFlags] -> m ()
actorAllocate a
self ActorBox
box [AllocationFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActorBox
box' <- ActorBox -> IO (Ptr ActorBox)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ActorBox
box
    let flags' :: CUInt
flags' = [AllocationFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [AllocationFlags]
flags
    Ptr Actor -> Ptr ActorBox -> CUInt -> IO ()
clutter_actor_allocate Ptr Actor
self' Ptr ActorBox
box' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ActorBox -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ActorBox
box
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAllocateMethodInfo
instance (signature ~ (Clutter.ActorBox.ActorBox -> [Clutter.Flags.AllocationFlags] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorAllocateMethodInfo a signature where
    overloadedMethod = actorAllocate

instance O.OverloadedMethodInfo ActorAllocateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAllocate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAllocate"
        })


#endif

-- method Actor::allocate_align_fill
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorBox" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterActorBox, containing the available width and height"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x_align"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the horizontal alignment, between 0 and 1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y_align"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the vertical alignment, between 0 and 1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x_fill"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the actor should fill horizontally"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y_fill"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the actor should fill vertically"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "AllocationFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "allocation flags to be passed to clutter_actor_allocate()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_allocate_align_fill" clutter_actor_allocate_align_fill :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.ActorBox.ActorBox ->        -- box : TInterface (Name {namespace = "Clutter", name = "ActorBox"})
    CDouble ->                              -- x_align : TBasicType TDouble
    CDouble ->                              -- y_align : TBasicType TDouble
    CInt ->                                 -- x_fill : TBasicType TBoolean
    CInt ->                                 -- y_fill : TBasicType TBoolean
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "AllocationFlags"})
    IO ()

-- | 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 t'GI.Clutter.Structs.ActorBox.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:requestMode]("GI.Clutter.Objects.Actor#g:attr:requestMode") 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:xAlign]("GI.Clutter.Objects.Actor#g:attr:xAlign")
-- and [Actor:yAlign]("GI.Clutter.Objects.Actor#g:attr:yAlign") properties, instead, and just call
-- 'GI.Clutter.Objects.Actor.actorAllocate' inside their t'GI.Clutter.Structs.ActorClass.ActorClass'.@/allocate/@()
-- implementation.
-- 
-- /Since: 1.4/
actorAllocateAlignFill ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.ActorBox.ActorBox
    -- ^ /@box@/: a t'GI.Clutter.Structs.ActorBox.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
    -> [Clutter.Flags.AllocationFlags]
    -- ^ /@flags@/: allocation flags to be passed to 'GI.Clutter.Objects.Actor.actorAllocate'
    -> m ()
actorAllocateAlignFill :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a
-> ActorBox
-> Double
-> Double
-> Bool
-> Bool
-> [AllocationFlags]
-> m ()
actorAllocateAlignFill a
self ActorBox
box Double
xAlign Double
yAlign Bool
xFill Bool
yFill [AllocationFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActorBox
box' <- ActorBox -> IO (Ptr ActorBox)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ActorBox
box
    let xAlign' :: CDouble
xAlign' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
xAlign
    let yAlign' :: CDouble
yAlign' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
yAlign
    let xFill' :: CInt
xFill' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
xFill
    let yFill' :: CInt
yFill' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
yFill
    let flags' :: CUInt
flags' = [AllocationFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [AllocationFlags]
flags
    Ptr Actor
-> Ptr ActorBox
-> CDouble
-> CDouble
-> CInt
-> CInt
-> CUInt
-> IO ()
clutter_actor_allocate_align_fill Ptr Actor
self' Ptr ActorBox
box' CDouble
xAlign' CDouble
yAlign' CInt
xFill' CInt
yFill' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ActorBox -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ActorBox
box
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAllocateAlignFillMethodInfo
instance (signature ~ (Clutter.ActorBox.ActorBox -> Double -> Double -> Bool -> Bool -> [Clutter.Flags.AllocationFlags] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorAllocateAlignFillMethodInfo a signature where
    overloadedMethod = actorAllocateAlignFill

instance O.OverloadedMethodInfo ActorAllocateAlignFillMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAllocateAlignFill",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAllocateAlignFill"
        })


#endif

-- method Actor::allocate_available_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the actor's X coordinate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the actor's Y coordinate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "available_width"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the maximum available width, or -1 to use the\n  actor's natural width"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "available_height"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the maximum available height, or -1 to use the\n  actor's natural height"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "AllocationFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags controlling the allocation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_allocate_available_size" clutter_actor_allocate_available_size :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    CFloat ->                               -- available_width : TBasicType TFloat
    CFloat ->                               -- available_height : TBasicType TFloat
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "AllocationFlags"})
    IO ()

-- | Allocates /@self@/ taking into account the t'GI.Clutter.Objects.Actor.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/
actorAllocateAvailableSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.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
    -> [Clutter.Flags.AllocationFlags]
    -- ^ /@flags@/: flags controlling the allocation
    -> m ()
actorAllocateAvailableSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> Float -> Float -> [AllocationFlags] -> m ()
actorAllocateAvailableSize a
self Float
x Float
y Float
availableWidth Float
availableHeight [AllocationFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    let availableWidth' :: CFloat
availableWidth' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
availableWidth
    let availableHeight' :: CFloat
availableHeight' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
availableHeight
    let flags' :: CUInt
flags' = [AllocationFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [AllocationFlags]
flags
    Ptr Actor -> CFloat -> CFloat -> CFloat -> CFloat -> CUInt -> IO ()
clutter_actor_allocate_available_size Ptr Actor
self' CFloat
x' CFloat
y' CFloat
availableWidth' CFloat
availableHeight' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAllocateAvailableSizeMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> [Clutter.Flags.AllocationFlags] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorAllocateAvailableSizeMethodInfo a signature where
    overloadedMethod = actorAllocateAvailableSize

instance O.OverloadedMethodInfo ActorAllocateAvailableSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAllocateAvailableSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAllocateAvailableSize"
        })


#endif

-- method Actor::allocate_preferred_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "AllocationFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "flags controlling the allocation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_allocate_preferred_size" clutter_actor_allocate_preferred_size :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "AllocationFlags"})
    IO ()

-- | Allocates the natural size of /@self@/.
-- 
-- This function is a utility call for t'GI.Clutter.Objects.Actor.Actor' implementations
-- that allocates the actor\'s preferred natural size. It can be used
-- by fixed layout managers (like t'GI.Clutter.Objects.Group.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
-- t'GI.Clutter.Structs.ActorClass.ActorClass'.@/allocate/@ virtual function.
-- 
-- /Since: 0.8/
actorAllocatePreferredSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> [Clutter.Flags.AllocationFlags]
    -- ^ /@flags@/: flags controlling the allocation
    -> m ()
actorAllocatePreferredSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> [AllocationFlags] -> m ()
actorAllocatePreferredSize a
self [AllocationFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let flags' :: CUInt
flags' = [AllocationFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [AllocationFlags]
flags
    Ptr Actor -> CUInt -> IO ()
clutter_actor_allocate_preferred_size Ptr Actor
self' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorAllocatePreferredSizeMethodInfo
instance (signature ~ ([Clutter.Flags.AllocationFlags] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorAllocatePreferredSizeMethodInfo a signature where
    overloadedMethod = actorAllocatePreferredSize

instance O.OverloadedMethodInfo ActorAllocatePreferredSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAllocatePreferredSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAllocatePreferredSize"
        })


#endif

-- method Actor::animate_with_alphav
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "alpha"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Alpha" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterAlpha" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_properties"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "number of property names and values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "properties"
--           , argType = TCArray False (-1) 2 (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a vector\n   containing the property names to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "values"
--           , argType = TCArray False (-1) 2 TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a vector containing the\n   property values to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_properties"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of property names and values"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          , Arg
--              { argCName = "n_properties"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of property names and values"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "Animation" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_animate_with_alphav" clutter_actor_animate_with_alphav :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Alpha.Alpha ->              -- alpha : TInterface (Name {namespace = "Clutter", name = "Alpha"})
    Int32 ->                                -- n_properties : TBasicType TInt
    Ptr CString ->                          -- properties : TCArray False (-1) 2 (TBasicType TUTF8)
    Ptr B.GValue.GValue ->                  -- values : TCArray False (-1) 2 TGValue
    IO (Ptr Clutter.Animation.Animation)

{-# DEPRECATED actorAnimateWithAlphav ["(Since version 1.10)","Use the implicit transition for animatable properties","  in t'GI.Clutter.Objects.Actor.Actor' instead. See 'GI.Clutter.Objects.Actor.actorSaveEasingState',","  'GI.Clutter.Objects.Actor.actorSetEasingMode', 'GI.Clutter.Objects.Actor.actorSetEasingDuration',","  'GI.Clutter.Objects.Actor.actorSetEasingDelay', and 'GI.Clutter.Objects.Actor.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 t'GI.Clutter.Objects.Alpha.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/
actorAnimateWithAlphav ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Alpha.IsAlpha b) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@alpha@/: a t'GI.Clutter.Objects.Alpha.Alpha'
    -> [T.Text]
    -- ^ /@properties@/: a vector
    --    containing the property names to set
    -> [GValue]
    -- ^ /@values@/: a vector containing the
    --    property values to set
    -> m Clutter.Animation.Animation
    -- ^ __Returns:__ a t'GI.Clutter.Objects.Animation.Animation' object. The object is owned by the
    --   t'GI.Clutter.Objects.Actor.Actor' and should not be unreferenced with 'GI.GObject.Objects.Object.objectUnref'
actorAnimateWithAlphav :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsAlpha b) =>
a -> b -> [Text] -> [GValue] -> m Animation
actorAnimateWithAlphav a
actor b
alpha [Text]
properties [GValue]
values = IO Animation -> m Animation
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Animation -> m Animation) -> IO Animation -> m Animation
forall a b. (a -> b) -> a -> b
$ do
    let nProperties :: Int32
nProperties = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
values
    let properties_expected_length_ :: Int32
properties_expected_length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Text] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
properties
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int32
properties_expected_length_ Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int32
nProperties) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
        String -> IO ()
forall a. HasCallStack => String -> a
error String
"Clutter.actorAnimateWithAlphav : length of 'properties' does not agree with that of 'values'."
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    Ptr Alpha
alpha' <- b -> IO (Ptr Alpha)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
alpha
    Ptr CString
properties' <- [Text] -> IO (Ptr CString)
packUTF8CArray [Text]
properties
    Ptr GValue
values' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
values
    Ptr Animation
result <- Ptr Actor
-> Ptr Alpha
-> Int32
-> Ptr CString
-> Ptr GValue
-> IO (Ptr Animation)
clutter_actor_animate_with_alphav Ptr Actor
actor' Ptr Alpha
alpha' Int32
nProperties Ptr CString
properties' Ptr GValue
values'
    Text -> Ptr Animation -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorAnimateWithAlphav" Ptr Animation
result
    Animation
result' <- ((ManagedPtr Animation -> Animation)
-> Ptr Animation -> IO Animation
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Animation -> Animation
Clutter.Animation.Animation) Ptr Animation
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
alpha
    (GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
values
    (Int32 -> (CString -> IO ()) -> Ptr CString -> IO ()
forall a b c.
(Storable a, Integral b) =>
b -> (a -> IO c) -> Ptr a -> IO ()
mapCArrayWithLength Int32
nProperties) CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
properties'
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
properties'
    Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
values'
    Animation -> IO Animation
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Animation
result'

#if defined(ENABLE_OVERLOADING)
data ActorAnimateWithAlphavMethodInfo
instance (signature ~ (b -> [T.Text] -> [GValue] -> m Clutter.Animation.Animation), MonadIO m, IsActor a, Clutter.Alpha.IsAlpha b) => O.OverloadedMethod ActorAnimateWithAlphavMethodInfo a signature where
    overloadedMethod = actorAnimateWithAlphav

instance O.OverloadedMethodInfo ActorAnimateWithAlphavMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAnimateWithAlphav",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAnimateWithAlphav"
        })


#endif

-- method Actor::animate_with_timelinev
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType = TBasicType TULong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an animation mode logical id"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeline"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Timeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTimeline" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_properties"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "number of property names and values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "properties"
--           , argType = TCArray False (-1) 3 (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a vector\n   containing the property names to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "values"
--           , argType = TCArray False (-1) 3 TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a vector containing the\n   property values to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_properties"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of property names and values"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          , Arg
--              { argCName = "n_properties"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of property names and values"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "Animation" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_animate_with_timelinev" clutter_actor_animate_with_timelinev :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    FCT.CULong ->                           -- mode : TBasicType TULong
    Ptr Clutter.Timeline.Timeline ->        -- timeline : TInterface (Name {namespace = "Clutter", name = "Timeline"})
    Int32 ->                                -- n_properties : TBasicType TInt
    Ptr CString ->                          -- properties : TCArray False (-1) 3 (TBasicType TUTF8)
    Ptr B.GValue.GValue ->                  -- values : TCArray False (-1) 3 TGValue
    IO (Ptr Clutter.Animation.Animation)

{-# DEPRECATED actorAnimateWithTimelinev ["(Since version 1.12)","Use the implicit transition for animatable properties","  in t'GI.Clutter.Objects.Actor.Actor' instead. See 'GI.Clutter.Objects.Actor.actorSaveEasingState',","  'GI.Clutter.Objects.Actor.actorSetEasingMode', 'GI.Clutter.Objects.Actor.actorSetEasingDuration',","  'GI.Clutter.Objects.Actor.actorSetEasingDelay', and 'GI.Clutter.Objects.Actor.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/
actorAnimateWithTimelinev ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Timeline.IsTimeline b) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> FCT.CULong
    -- ^ /@mode@/: an animation mode logical id
    -> b
    -- ^ /@timeline@/: a t'GI.Clutter.Objects.Timeline.Timeline'
    -> [T.Text]
    -- ^ /@properties@/: a vector
    --    containing the property names to set
    -> [GValue]
    -- ^ /@values@/: a vector containing the
    --    property values to set
    -> m Clutter.Animation.Animation
    -- ^ __Returns:__ a t'GI.Clutter.Objects.Animation.Animation' object. The object is
    --    owned by the t'GI.Clutter.Objects.Actor.Actor' and should not be unreferenced with
    --    'GI.GObject.Objects.Object.objectUnref'
actorAnimateWithTimelinev :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsTimeline b) =>
a -> SignalHandlerId -> b -> [Text] -> [GValue] -> m Animation
actorAnimateWithTimelinev a
actor SignalHandlerId
mode b
timeline [Text]
properties [GValue]
values = IO Animation -> m Animation
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Animation -> m Animation) -> IO Animation -> m Animation
forall a b. (a -> b) -> a -> b
$ do
    let nProperties :: Int32
nProperties = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
values
    let properties_expected_length_ :: Int32
properties_expected_length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Text] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
properties
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int32
properties_expected_length_ Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int32
nProperties) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
        String -> IO ()
forall a. HasCallStack => String -> a
error String
"Clutter.actorAnimateWithTimelinev : length of 'properties' does not agree with that of 'values'."
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    Ptr Timeline
timeline' <- b -> IO (Ptr Timeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
timeline
    Ptr CString
properties' <- [Text] -> IO (Ptr CString)
packUTF8CArray [Text]
properties
    Ptr GValue
values' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
values
    Ptr Animation
result <- Ptr Actor
-> SignalHandlerId
-> Ptr Timeline
-> Int32
-> Ptr CString
-> Ptr GValue
-> IO (Ptr Animation)
clutter_actor_animate_with_timelinev Ptr Actor
actor' SignalHandlerId
mode Ptr Timeline
timeline' Int32
nProperties Ptr CString
properties' Ptr GValue
values'
    Text -> Ptr Animation -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorAnimateWithTimelinev" Ptr Animation
result
    Animation
result' <- ((ManagedPtr Animation -> Animation)
-> Ptr Animation -> IO Animation
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Animation -> Animation
Clutter.Animation.Animation) Ptr Animation
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
timeline
    (GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
values
    (Int32 -> (CString -> IO ()) -> Ptr CString -> IO ()
forall a b c.
(Storable a, Integral b) =>
b -> (a -> IO c) -> Ptr a -> IO ()
mapCArrayWithLength Int32
nProperties) CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
properties'
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
properties'
    Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
values'
    Animation -> IO Animation
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Animation
result'

#if defined(ENABLE_OVERLOADING)
data ActorAnimateWithTimelinevMethodInfo
instance (signature ~ (FCT.CULong -> b -> [T.Text] -> [GValue] -> m Clutter.Animation.Animation), MonadIO m, IsActor a, Clutter.Timeline.IsTimeline b) => O.OverloadedMethod ActorAnimateWithTimelinevMethodInfo a signature where
    overloadedMethod = actorAnimateWithTimelinev

instance O.OverloadedMethodInfo ActorAnimateWithTimelinevMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAnimateWithTimelinev",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAnimateWithTimelinev"
        })


#endif

-- method Actor::animatev
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType = TBasicType TULong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an animation mode logical id"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "duration"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "duration of the animation, in milliseconds"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_properties"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "number of property names and values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "properties"
--           , argType = TCArray False (-1) 3 (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a vector\n   containing the property names to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "values"
--           , argType = TCArray False (-1) 3 TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a vector containing the\n   property values to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_properties"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of property names and values"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          , Arg
--              { argCName = "n_properties"
--              , argType = TBasicType TInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of property names and values"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , argCallbackUserData = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "Animation" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_animatev" clutter_actor_animatev :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    FCT.CULong ->                           -- mode : TBasicType TULong
    Word32 ->                               -- duration : TBasicType TUInt
    Int32 ->                                -- n_properties : TBasicType TInt
    Ptr CString ->                          -- properties : TCArray False (-1) 3 (TBasicType TUTF8)
    Ptr B.GValue.GValue ->                  -- values : TCArray False (-1) 3 TGValue
    IO (Ptr Clutter.Animation.Animation)

{-# DEPRECATED actorAnimatev ["(Since version 1.12)","Use the implicit transition for animatable properties","  in t'GI.Clutter.Objects.Actor.Actor' instead. See 'GI.Clutter.Objects.Actor.actorSaveEasingState',","  'GI.Clutter.Objects.Actor.actorSetEasingMode', 'GI.Clutter.Objects.Actor.actorSetEasingDuration',","  'GI.Clutter.Objects.Actor.actorSetEasingDelay', and 'GI.Clutter.Objects.Actor.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/
actorAnimatev ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> FCT.CULong
    -- ^ /@mode@/: an animation mode logical id
    -> Word32
    -- ^ /@duration@/: duration of the animation, in milliseconds
    -> [T.Text]
    -- ^ /@properties@/: a vector
    --    containing the property names to set
    -> [GValue]
    -- ^ /@values@/: a vector containing the
    --    property values to set
    -> m Clutter.Animation.Animation
    -- ^ __Returns:__ a t'GI.Clutter.Objects.Animation.Animation' object. The object is
    --   owned by the t'GI.Clutter.Objects.Actor.Actor' and should not be unreferenced with
    --   'GI.GObject.Objects.Object.objectUnref'
actorAnimatev :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> SignalHandlerId -> Word32 -> [Text] -> [GValue] -> m Animation
actorAnimatev a
actor SignalHandlerId
mode Word32
duration [Text]
properties [GValue]
values = IO Animation -> m Animation
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Animation -> m Animation) -> IO Animation -> m Animation
forall a b. (a -> b) -> a -> b
$ do
    let nProperties :: Int32
nProperties = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
values
    let properties_expected_length_ :: Int32
properties_expected_length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Text] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
properties
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int32
properties_expected_length_ Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Int32
nProperties) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
        String -> IO ()
forall a. HasCallStack => String -> a
error String
"Clutter.actorAnimatev : length of 'properties' does not agree with that of 'values'."
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    Ptr CString
properties' <- [Text] -> IO (Ptr CString)
packUTF8CArray [Text]
properties
    Ptr GValue
values' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
values
    Ptr Animation
result <- Ptr Actor
-> SignalHandlerId
-> Word32
-> Int32
-> Ptr CString
-> Ptr GValue
-> IO (Ptr Animation)
clutter_actor_animatev Ptr Actor
actor' SignalHandlerId
mode Word32
duration Int32
nProperties Ptr CString
properties' Ptr GValue
values'
    Text -> Ptr Animation -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorAnimatev" Ptr Animation
result
    Animation
result' <- ((ManagedPtr Animation -> Animation)
-> Ptr Animation -> IO Animation
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Animation -> Animation
Clutter.Animation.Animation) Ptr Animation
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    (GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
values
    (Int32 -> (CString -> IO ()) -> Ptr CString -> IO ()
forall a b c.
(Storable a, Integral b) =>
b -> (a -> IO c) -> Ptr a -> IO ()
mapCArrayWithLength Int32
nProperties) CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
properties'
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
properties'
    Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
values'
    Animation -> IO Animation
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Animation
result'

#if defined(ENABLE_OVERLOADING)
data ActorAnimatevMethodInfo
instance (signature ~ (FCT.CULong -> Word32 -> [T.Text] -> [GValue] -> m Clutter.Animation.Animation), MonadIO m, IsActor a) => O.OverloadedMethod ActorAnimatevMethodInfo a signature where
    overloadedMethod = actorAnimatev

instance O.OverloadedMethodInfo ActorAnimatevMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorAnimatev",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorAnimatev"
        })


#endif

-- method Actor::apply_relative_transform_to_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ancestor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #ClutterActor ancestor, or %NULL to use the\n  default #ClutterStage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Vertex" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A point as #ClutterVertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "vertex"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Vertex" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The translated #ClutterVertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_apply_relative_transform_to_point" clutter_actor_apply_relative_transform_to_point :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- ancestor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Vertex.Vertex ->            -- point : TInterface (Name {namespace = "Clutter", name = "Vertex"})
    Ptr Clutter.Vertex.Vertex ->            -- vertex : TInterface (Name {namespace = "Clutter", name = "Vertex"})
    IO ()

-- | 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 'P.Nothing' the ancestor will be the t'GI.Clutter.Objects.Stage.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 'GI.Clutter.Objects.Actor.actorApplyTransformToPoint'.
-- 
-- /Since: 0.6/
actorApplyRelativeTransformToPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (b)
    -- ^ /@ancestor@/: A t'GI.Clutter.Objects.Actor.Actor' ancestor, or 'P.Nothing' to use the
    --   default t'GI.Clutter.Objects.Stage.Stage'
    -> Clutter.Vertex.Vertex
    -- ^ /@point@/: A point as t'GI.Clutter.Structs.Vertex.Vertex'
    -> m (Clutter.Vertex.Vertex)
actorApplyRelativeTransformToPoint :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> Maybe b -> Vertex -> m Vertex
actorApplyRelativeTransformToPoint a
self Maybe b
ancestor Vertex
point = IO Vertex -> m Vertex
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Vertex -> m Vertex) -> IO Vertex -> m Vertex
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
maybeAncestor <- case Maybe b
ancestor of
        Maybe b
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
        Just b
jAncestor -> do
            Ptr Actor
jAncestor' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jAncestor
            Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jAncestor'
    Ptr Vertex
point' <- Vertex -> IO (Ptr Vertex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vertex
point
    Ptr Vertex
vertex <- Int -> IO (Ptr Vertex)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
12 :: IO (Ptr Clutter.Vertex.Vertex)
    Ptr Actor -> Ptr Actor -> Ptr Vertex -> Ptr Vertex -> IO ()
clutter_actor_apply_relative_transform_to_point Ptr Actor
self' Ptr Actor
maybeAncestor Ptr Vertex
point' Ptr Vertex
vertex
    Vertex
vertex' <- ((ManagedPtr Vertex -> Vertex) -> Ptr Vertex -> IO Vertex
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Vertex -> Vertex
Clutter.Vertex.Vertex) Ptr Vertex
vertex
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
ancestor b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Vertex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Vertex
point
    Vertex -> IO Vertex
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Vertex
vertex'

#if defined(ENABLE_OVERLOADING)
data ActorApplyRelativeTransformToPointMethodInfo
instance (signature ~ (Maybe (b) -> Clutter.Vertex.Vertex -> m (Clutter.Vertex.Vertex)), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorApplyRelativeTransformToPointMethodInfo a signature where
    overloadedMethod = actorApplyRelativeTransformToPoint

instance O.OverloadedMethodInfo ActorApplyRelativeTransformToPointMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorApplyRelativeTransformToPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorApplyRelativeTransformToPoint"
        })


#endif

-- method Actor::apply_transform_to_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Vertex" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A point as #ClutterVertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "vertex"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Vertex" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The translated #ClutterVertex"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_apply_transform_to_point" clutter_actor_apply_transform_to_point :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Vertex.Vertex ->            -- point : TInterface (Name {namespace = "Clutter", name = "Vertex"})
    Ptr Clutter.Vertex.Vertex ->            -- vertex : TInterface (Name {namespace = "Clutter", name = "Vertex"})
    IO ()

-- | 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/
actorApplyTransformToPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Vertex.Vertex
    -- ^ /@point@/: A point as t'GI.Clutter.Structs.Vertex.Vertex'
    -> m (Clutter.Vertex.Vertex)
actorApplyTransformToPoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Vertex -> m Vertex
actorApplyTransformToPoint a
self Vertex
point = IO Vertex -> m Vertex
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Vertex -> m Vertex) -> IO Vertex -> m Vertex
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Vertex
point' <- Vertex -> IO (Ptr Vertex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vertex
point
    Ptr Vertex
vertex <- Int -> IO (Ptr Vertex)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
12 :: IO (Ptr Clutter.Vertex.Vertex)
    Ptr Actor -> Ptr Vertex -> Ptr Vertex -> IO ()
clutter_actor_apply_transform_to_point Ptr Actor
self' Ptr Vertex
point' Ptr Vertex
vertex
    Vertex
vertex' <- ((ManagedPtr Vertex -> Vertex) -> Ptr Vertex -> IO Vertex
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Vertex -> Vertex
Clutter.Vertex.Vertex) Ptr Vertex
vertex
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Vertex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Vertex
point
    Vertex -> IO Vertex
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Vertex
vertex'

#if defined(ENABLE_OVERLOADING)
data ActorApplyTransformToPointMethodInfo
instance (signature ~ (Clutter.Vertex.Vertex -> m (Clutter.Vertex.Vertex)), MonadIO m, IsActor a) => O.OverloadedMethod ActorApplyTransformToPointMethodInfo a signature where
    overloadedMethod = actorApplyTransformToPoint

instance O.OverloadedMethodInfo ActorApplyTransformToPointMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorApplyTransformToPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorApplyTransformToPoint"
        })


#endif

-- method Actor::bind_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "ListModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GListModel" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "create_child_func"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "ActorCreateChildFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a function that creates #ClutterActor instances\n  from the contents of the @model"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 3
--           , argDestroy = 4
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data passed to @create_child_func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "notify"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "function called when unsetting the @model"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_bind_model" clutter_actor_bind_model :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Gio.ListModel.ListModel ->          -- model : TInterface (Name {namespace = "Gio", name = "ListModel"})
    FunPtr Clutter.Callbacks.C_ActorCreateChildFunc -> -- create_child_func : TInterface (Name {namespace = "Clutter", name = "ActorCreateChildFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | Binds a t'GI.Gio.Interfaces.ListModel.ListModel' to a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- If the t'GI.Clutter.Objects.Actor.Actor' was already bound to a t'GI.Gio.Interfaces.ListModel.ListModel', the previous
-- binding is destroyed.
-- 
-- The existing children of t'GI.Clutter.Objects.Actor.Actor' are destroyed when setting a
-- model, and new children are created and added, representing the contents
-- of the /@model@/. The t'GI.Clutter.Objects.Actor.Actor' is updated whenever the /@model@/ changes.
-- If /@model@/ is 'P.Nothing', the t'GI.Clutter.Objects.Actor.Actor' is left empty.
-- 
-- When a t'GI.Clutter.Objects.Actor.Actor' is bound to a model, adding and removing children
-- directly is undefined behaviour.
-- 
-- /Since: 1.24/
actorBindModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Gio.ListModel.IsListModel b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (b)
    -- ^ /@model@/: a t'GI.Gio.Interfaces.ListModel.ListModel'
    -> Clutter.Callbacks.ActorCreateChildFunc
    -- ^ /@createChildFunc@/: a function that creates t'GI.Clutter.Objects.Actor.Actor' instances
    --   from the contents of the /@model@/
    -> m ()
actorBindModel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsListModel b) =>
a -> Maybe b -> ActorCreateChildFunc -> m ()
actorBindModel a
self Maybe b
model ActorCreateChildFunc
createChildFunc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
maybeModel <- case Maybe b
model of
        Maybe b
Nothing -> Ptr ListModel -> IO (Ptr ListModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
forall a. Ptr a
nullPtr
        Just b
jModel -> do
            Ptr ListModel
jModel' <- b -> IO (Ptr ListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jModel
            Ptr ListModel -> IO (Ptr ListModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
jModel'
    FunPtr C_ActorCreateChildFunc
createChildFunc' <- C_ActorCreateChildFunc -> IO (FunPtr C_ActorCreateChildFunc)
Clutter.Callbacks.mk_ActorCreateChildFunc (Maybe (Ptr (FunPtr C_ActorCreateChildFunc))
-> ActorCreateChildFunc_WithClosures -> C_ActorCreateChildFunc
Clutter.Callbacks.wrap_ActorCreateChildFunc Maybe (Ptr (FunPtr C_ActorCreateChildFunc))
forall a. Maybe a
Nothing (ActorCreateChildFunc -> ActorCreateChildFunc_WithClosures
Clutter.Callbacks.drop_closures_ActorCreateChildFunc ActorCreateChildFunc
createChildFunc))
    let userData :: Ptr ()
userData = FunPtr C_ActorCreateChildFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_ActorCreateChildFunc
createChildFunc'
    let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
    Ptr Actor
-> Ptr ListModel
-> FunPtr C_ActorCreateChildFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
clutter_actor_bind_model Ptr Actor
self' Ptr ListModel
maybeModel FunPtr C_ActorCreateChildFunc
createChildFunc' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
model b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorBindModelMethodInfo
instance (signature ~ (Maybe (b) -> Clutter.Callbacks.ActorCreateChildFunc -> m ()), MonadIO m, IsActor a, Gio.ListModel.IsListModel b) => O.OverloadedMethod ActorBindModelMethodInfo a signature where
    overloadedMethod = actorBindModel

instance O.OverloadedMethodInfo ActorBindModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorBindModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorBindModel"
        })


#endif

-- method Actor::clear_actions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_clear_actions" clutter_actor_clear_actions :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Clears the list of actions applied to /@self@/
-- 
-- /Since: 1.4/
actorClearActions ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorClearActions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorClearActions a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_clear_actions Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorClearActionsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorClearActionsMethodInfo a signature where
    overloadedMethod = actorClearActions

instance O.OverloadedMethodInfo ActorClearActionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorClearActions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorClearActions"
        })


#endif

-- method Actor::clear_constraints
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_clear_constraints" clutter_actor_clear_constraints :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Clears the list of constraints applied to /@self@/
-- 
-- /Since: 1.4/
actorClearConstraints ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorClearConstraints :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorClearConstraints a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_clear_constraints Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorClearConstraintsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorClearConstraintsMethodInfo a signature where
    overloadedMethod = actorClearConstraints

instance O.OverloadedMethodInfo ActorClearConstraintsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorClearConstraints",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorClearConstraints"
        })


#endif

-- method Actor::clear_effects
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_clear_effects" clutter_actor_clear_effects :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Clears the list of effects applied to /@self@/
-- 
-- /Since: 1.4/
actorClearEffects ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorClearEffects :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorClearEffects a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_clear_effects Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorClearEffectsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorClearEffectsMethodInfo a signature where
    overloadedMethod = actorClearEffects

instance O.OverloadedMethodInfo ActorClearEffectsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorClearEffects",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorClearEffects"
        })


#endif

-- method Actor::contains
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "descendant"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor, possibly contained in @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_contains" clutter_actor_contains :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- descendant : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | 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 'P.True'.
-- 
-- /Since: 1.4/
actorContains ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@descendant@/: A t'GI.Clutter.Objects.Actor.Actor', possibly contained in /@self@/
    -> m Bool
    -- ^ __Returns:__ whether /@descendent@/ is contained within /@self@/
actorContains :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> b -> m Bool
actorContains a
self b
descendant = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
descendant' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
descendant
    CInt
result <- Ptr Actor -> Ptr Actor -> IO CInt
clutter_actor_contains Ptr Actor
self' Ptr Actor
descendant'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
descendant
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorContainsMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorContainsMethodInfo a signature where
    overloadedMethod = actorContains

instance O.OverloadedMethodInfo ActorContainsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorContains",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorContains"
        })


#endif

-- method Actor::continue_paint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_continue_paint" clutter_actor_continue_paint :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Run the next stage of the paint sequence. This function should only
-- be called within the implementation of the ‘run’ virtual of a
-- t'GI.Clutter.Objects.Effect.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/
actorContinuePaint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorContinuePaint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorContinuePaint a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_continue_paint Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorContinuePaintMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorContinuePaintMethodInfo a signature where
    overloadedMethod = actorContinuePaint

instance O.OverloadedMethodInfo ActorContinuePaintMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorContinuePaint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorContinuePaint"
        })


#endif

-- method Actor::create_pango_context
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "Context" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_create_pango_context" clutter_actor_create_pango_context :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Pango.Context.Context)

-- | Creates a t'GI.Pango.Objects.Context.Context' for the given actor. The t'GI.Pango.Objects.Context.Context'
-- is already configured using the appropriate font map, resolution
-- and font options.
-- 
-- See also 'GI.Clutter.Objects.Actor.actorGetPangoContext'.
-- 
-- /Since: 1.0/
actorCreatePangoContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Pango.Context.Context
    -- ^ __Returns:__ the newly created t'GI.Pango.Objects.Context.Context'.
    --   Use 'GI.GObject.Objects.Object.objectUnref' on the returned value to deallocate its
    --   resources
actorCreatePangoContext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Context
actorCreatePangoContext a
self = IO Context -> m Context
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Context -> m Context) -> IO Context -> m Context
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Context
result <- Ptr Actor -> IO (Ptr Context)
clutter_actor_create_pango_context Ptr Actor
self'
    Text -> Ptr Context -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorCreatePangoContext" Ptr Context
result
    Context
result' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Context -> Context
Pango.Context.Context) Ptr Context
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Context -> IO Context
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Context
result'

#if defined(ENABLE_OVERLOADING)
data ActorCreatePangoContextMethodInfo
instance (signature ~ (m Pango.Context.Context), MonadIO m, IsActor a) => O.OverloadedMethod ActorCreatePangoContextMethodInfo a signature where
    overloadedMethod = actorCreatePangoContext

instance O.OverloadedMethodInfo ActorCreatePangoContextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorCreatePangoContext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorCreatePangoContext"
        })


#endif

-- method Actor::create_pango_layout
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the text to set on the #PangoLayout, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "Layout" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_create_pango_layout" clutter_actor_create_pango_layout :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- text : TBasicType TUTF8
    IO (Ptr Pango.Layout.Layout)

-- | Creates a new t'GI.Pango.Objects.Layout.Layout' from the same t'GI.Pango.Objects.Context.Context' used
-- by the t'GI.Clutter.Objects.Actor.Actor'. The t'GI.Pango.Objects.Layout.Layout' is already configured
-- with the font map, resolution and font options, and the
-- given /@text@/.
-- 
-- If you want to keep around a t'GI.Pango.Objects.Layout.Layout' created by this
-- function you will have to connect to the [Backend::fontChanged]("GI.Clutter.Objects.Backend#g:signal:fontChanged")
-- and [Backend::resolutionChanged]("GI.Clutter.Objects.Backend#g:signal:resolutionChanged") signals, and call
-- 'GI.Pango.Objects.Layout.layoutContextChanged' in response to them.
-- 
-- /Since: 1.0/
actorCreatePangoLayout ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (T.Text)
    -- ^ /@text@/: the text to set on the t'GI.Pango.Objects.Layout.Layout', or 'P.Nothing'
    -> m Pango.Layout.Layout
    -- ^ __Returns:__ the newly created t'GI.Pango.Objects.Layout.Layout'.
    --   Use 'GI.GObject.Objects.Object.objectUnref' when done
actorCreatePangoLayout :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Maybe Text -> m Layout
actorCreatePangoLayout a
self Maybe Text
text = IO Layout -> m Layout
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Layout -> m Layout) -> IO Layout -> m Layout
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeText <- case Maybe Text
text of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jText -> do
            CString
jText' <- Text -> IO CString
textToCString Text
jText
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jText'
    Ptr Layout
result <- Ptr Actor -> CString -> IO (Ptr Layout)
clutter_actor_create_pango_layout Ptr Actor
self' CString
maybeText
    Text -> Ptr Layout -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorCreatePangoLayout" Ptr Layout
result
    Layout
result' <- ((ManagedPtr Layout -> Layout) -> Ptr Layout -> IO Layout
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Layout -> Layout
Pango.Layout.Layout) Ptr Layout
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeText
    Layout -> IO Layout
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Layout
result'

#if defined(ENABLE_OVERLOADING)
data ActorCreatePangoLayoutMethodInfo
instance (signature ~ (Maybe (T.Text) -> m Pango.Layout.Layout), MonadIO m, IsActor a) => O.OverloadedMethod ActorCreatePangoLayoutMethodInfo a signature where
    overloadedMethod = actorCreatePangoLayout

instance O.OverloadedMethodInfo ActorCreatePangoLayoutMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorCreatePangoLayout",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorCreatePangoLayout"
        })


#endif

-- method Actor::destroy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_destroy" clutter_actor_destroy :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | 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 t'GI.Clutter.Objects.Stage.Stage' returned by
-- 'GI.Clutter.Objects.Stage.stageGetDefault'.
actorDestroy ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorDestroy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorDestroy a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_destroy Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorDestroyMethodInfo a signature where
    overloadedMethod = actorDestroy

instance O.OverloadedMethodInfo ActorDestroyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorDestroy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorDestroy"
        })


#endif

-- method Actor::destroy_all_children
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_destroy_all_children" clutter_actor_destroy_all_children :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | 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
-- [Actor::destroy]("GI.Clutter.Objects.Actor#g:signal:destroy") signal is emitted on each child of the
-- actor.
-- 
-- By default, t'GI.Clutter.Objects.Actor.Actor' will emit the [Actor::destroy]("GI.Clutter.Objects.Actor#g:signal:destroy") signal
-- when its reference count drops to 0; the default handler of the
-- [Actor::destroy]("GI.Clutter.Objects.Actor#g:signal: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 'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorRemoveAllChildren' and want to reuse
-- the actors, you should use 'GI.Clutter.Objects.Actor.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/
actorDestroyAllChildren ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorDestroyAllChildren :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorDestroyAllChildren a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_destroy_all_children Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorDestroyAllChildrenMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorDestroyAllChildrenMethodInfo a signature where
    overloadedMethod = actorDestroyAllChildren

instance O.OverloadedMethodInfo ActorDestroyAllChildrenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorDestroyAllChildren",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorDestroyAllChildren"
        })


#endif

-- method Actor::detach_animation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_detach_animation" clutter_actor_detach_animation :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorDetachAnimation ["(Since version 1.12)","Use the implicit transition for animatable properties","  in t'GI.Clutter.Objects.Actor.Actor' instead, and 'GI.Clutter.Objects.Actor.actorRemoveTransition' to","  remove the transition."] #-}
-- | Detaches the t'GI.Clutter.Objects.Animation.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 t'GI.Clutter.Objects.Animation.Animation' becomes invalid.
-- 
-- The [Animation::completed]("GI.Clutter.Objects.Animation#g:signal:completed") signal will not be emitted.
-- 
-- /Since: 1.4/
actorDetachAnimation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorDetachAnimation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorDetachAnimation a
actor = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    Ptr Actor -> IO ()
clutter_actor_detach_animation Ptr Actor
actor'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorDetachAnimationMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorDetachAnimationMethodInfo a signature where
    overloadedMethod = actorDetachAnimation

instance O.OverloadedMethodInfo ActorDetachAnimationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorDetachAnimation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorDetachAnimation"
        })


#endif

-- method Actor::event
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "capture"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if event in in capture phase, %FALSE otherwise."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_event" clutter_actor_event :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Event.Event ->              -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    CInt ->                                 -- capture : TBasicType TBoolean
    IO CInt

-- | 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/
actorEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Event.Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Bool
    -- ^ /@capture@/: 'P.True' if event in in capture phase, 'P.False' otherwise.
    -> m Bool
    -- ^ __Returns:__ the return value from the signal emission: 'P.True'
    --   if the actor handled the event, or 'P.False' if the event was
    --   not handled
actorEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Event -> Bool -> m Bool
actorEvent a
actor Event
event Bool
capture = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
    let capture' :: CInt
capture' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
capture
    CInt
result <- Ptr Actor -> Ptr Event -> CInt -> IO CInt
clutter_actor_event Ptr Actor
actor' Ptr Event
event' CInt
capture'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorEventMethodInfo
instance (signature ~ (Clutter.Event.Event -> Bool -> m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorEventMethodInfo a signature where
    overloadedMethod = actorEvent

instance O.OverloadedMethodInfo ActorEventMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorEvent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorEvent"
        })


#endif

-- XXX Could not generate method Actor::get_abs_allocation_vertices
-- Not implemented: Don't know how to allocate "verts" of type TCArray False 4 (-1) (TInterface (Name {namespace = "Clutter", name = "Vertex"}))
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data ActorGetAbsAllocationVerticesMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getAbsAllocationVertices" Actor) => O.OverloadedMethod ActorGetAbsAllocationVerticesMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "getAbsAllocationVertices" Actor) => O.OverloadedMethodInfo ActorGetAbsAllocationVerticesMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Actor::get_accessible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Atk" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_accessible" clutter_actor_get_accessible :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Atk.Object.Object)

-- | Returns the accessible object that describes the actor to an
-- assistive technology.
-- 
-- If no class-specific t'GI.Atk.Objects.Object.Object' implementation is available for the
-- actor instance in question, it will inherit an t'GI.Atk.Objects.Object.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.
actorGetAccessible ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Atk.Object.Object
    -- ^ __Returns:__ the t'GI.Atk.Objects.Object.Object' associated with /@actor@/
actorGetAccessible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Object
actorGetAccessible a
self = IO Object -> m Object
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Object
result <- Ptr Actor -> IO (Ptr Object)
clutter_actor_get_accessible Ptr Actor
self'
    Text -> Ptr Object -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetAccessible" Ptr Object
result
    Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Atk.Object.Object) Ptr Object
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Object -> IO Object
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetAccessibleMethodInfo
instance (signature ~ (m Atk.Object.Object), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetAccessibleMethodInfo a signature where
    overloadedMethod = actorGetAccessible

instance O.OverloadedMethodInfo ActorGetAccessibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetAccessible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetAccessible"
        })


#endif

-- method Actor::get_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the action to retrieve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Action" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_action" clutter_actor_get_action :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Clutter.Action.Action)

-- | Retrieves the t'GI.Clutter.Objects.Action.Action' with the given name in the list
-- of actions applied to /@self@/
-- 
-- /Since: 1.4/
actorGetAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the action to retrieve
    -> m Clutter.Action.Action
    -- ^ __Returns:__ a t'GI.Clutter.Objects.Action.Action' for the given
    --   name, or 'P.Nothing'. The returned t'GI.Clutter.Objects.Action.Action' is owned by the
    --   actor and it should not be unreferenced directly
actorGetAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m Action
actorGetAction a
self Text
name = IO Action -> m Action
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Action -> m Action) -> IO Action -> m Action
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Action
result <- Ptr Actor -> CString -> IO (Ptr Action)
clutter_actor_get_action Ptr Actor
self' CString
name'
    Text -> Ptr Action -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetAction" Ptr Action
result
    Action
result' <- ((ManagedPtr Action -> Action) -> Ptr Action -> IO Action
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Action -> Action
Clutter.Action.Action) Ptr Action
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Action -> IO Action
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Action
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetActionMethodInfo
instance (signature ~ (T.Text -> m Clutter.Action.Action), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetActionMethodInfo a signature where
    overloadedMethod = actorGetAction

instance O.OverloadedMethodInfo ActorGetActionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetAction"
        })


#endif

-- method Actor::get_actions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface Name { namespace = "Clutter" , name = "Action" }))
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_actions" clutter_actor_get_actions :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr (GList (Ptr Clutter.Action.Action)))

-- | Retrieves the list of actions applied to /@self@/
-- 
-- /Since: 1.4/
actorGetActions ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m [Clutter.Action.Action]
    -- ^ __Returns:__ a copy
    --   of the list of t'GI.Clutter.Objects.Action.Action's. The contents of the list are
    --   owned by the t'GI.Clutter.Objects.Actor.Actor'. Use @/g_list_free()/@ to free the resources
    --   allocated by the returned t'GI.GLib.Structs.List.List'
actorGetActions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m [Action]
actorGetActions a
self = IO [Action] -> m [Action]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Action] -> m [Action]) -> IO [Action] -> m [Action]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr (GList (Ptr Action))
result <- Ptr Actor -> IO (Ptr (GList (Ptr Action)))
clutter_actor_get_actions Ptr Actor
self'
    [Ptr Action]
result' <- Ptr (GList (Ptr Action)) -> IO [Ptr Action]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Action))
result
    [Action]
result'' <- (Ptr Action -> IO Action) -> [Ptr Action] -> IO [Action]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr Action -> Action) -> Ptr Action -> IO Action
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Action -> Action
Clutter.Action.Action) [Ptr Action]
result'
    Ptr (GList (Ptr Action)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Action))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [Action] -> IO [Action]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Action]
result''

#if defined(ENABLE_OVERLOADING)
data ActorGetActionsMethodInfo
instance (signature ~ (m [Clutter.Action.Action]), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetActionsMethodInfo a signature where
    overloadedMethod = actorGetActions

instance O.OverloadedMethodInfo ActorGetActionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetActions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetActions"
        })


#endif

-- method Actor::get_allocation_box
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorBox" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the function fills this in with the actor's allocation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_allocation_box" clutter_actor_get_allocation_box :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.ActorBox.ActorBox ->        -- box : TInterface (Name {namespace = "Clutter", name = "ActorBox"})
    IO ()

-- | 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/
actorGetAllocationBox ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m (Clutter.ActorBox.ActorBox)
actorGetAllocationBox :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ActorBox
actorGetAllocationBox a
self = IO ActorBox -> m ActorBox
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ActorBox -> m ActorBox) -> IO ActorBox -> m ActorBox
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActorBox
box <- Int -> IO (Ptr ActorBox)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.ActorBox.ActorBox)
    Ptr Actor -> Ptr ActorBox -> IO ()
clutter_actor_get_allocation_box Ptr Actor
self' Ptr ActorBox
box
    ActorBox
box' <- ((ManagedPtr ActorBox -> ActorBox) -> Ptr ActorBox -> IO ActorBox
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ActorBox -> ActorBox
Clutter.ActorBox.ActorBox) Ptr ActorBox
box
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ActorBox -> IO ActorBox
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ActorBox
box'

#if defined(ENABLE_OVERLOADING)
data ActorGetAllocationBoxMethodInfo
instance (signature ~ (m (Clutter.ActorBox.ActorBox)), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetAllocationBoxMethodInfo a signature where
    overloadedMethod = actorGetAllocationBox

instance O.OverloadedMethodInfo ActorGetAllocationBoxMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetAllocationBox",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetAllocationBox"
        })


#endif

-- method Actor::get_allocation_geometry
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "geom"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Geometry" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "allocation geometry in pixels"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_allocation_geometry" clutter_actor_get_allocation_geometry :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Geometry.Geometry ->        -- geom : TInterface (Name {namespace = "Clutter", name = "Geometry"})
    IO ()

{-# DEPRECATED actorGetAllocationGeometry ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.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/
actorGetAllocationGeometry ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m (Clutter.Geometry.Geometry)
actorGetAllocationGeometry :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Geometry
actorGetAllocationGeometry a
self = IO Geometry -> m Geometry
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Geometry -> m Geometry) -> IO Geometry -> m Geometry
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Geometry
geom <- Int -> IO (Ptr Geometry)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.Geometry.Geometry)
    Ptr Actor -> Ptr Geometry -> IO ()
clutter_actor_get_allocation_geometry Ptr Actor
self' Ptr Geometry
geom
    Geometry
geom' <- ((ManagedPtr Geometry -> Geometry) -> Ptr Geometry -> IO Geometry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Geometry -> Geometry
Clutter.Geometry.Geometry) Ptr Geometry
geom
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Geometry -> IO Geometry
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Geometry
geom'

#if defined(ENABLE_OVERLOADING)
data ActorGetAllocationGeometryMethodInfo
instance (signature ~ (m (Clutter.Geometry.Geometry)), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetAllocationGeometryMethodInfo a signature where
    overloadedMethod = actorGetAllocationGeometry

instance O.OverloadedMethodInfo ActorGetAllocationGeometryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetAllocationGeometry",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetAllocationGeometry"
        })


#endif

-- XXX Could not generate method Actor::get_allocation_vertices
-- Not implemented: Don't know how to allocate "verts" of type TCArray False 4 (-1) (TInterface (Name {namespace = "Clutter", name = "Vertex"}))
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data ActorGetAllocationVerticesMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getAllocationVertices" Actor) => O.OverloadedMethod ActorGetAllocationVerticesMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "getAllocationVertices" Actor) => O.OverloadedMethodInfo ActorGetAllocationVerticesMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Actor::get_anchor_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "anchor_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the X coordinate of the anchor point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "anchor_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the Y coordinate of the anchor point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_anchor_point" clutter_actor_get_anchor_point :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- anchor_x : TBasicType TFloat
    Ptr CFloat ->                           -- anchor_y : TBasicType TFloat
    IO ()

{-# DEPRECATED actorGetAnchorPoint ["(Since version 1.12)","Use [Actor:pivotPoint](\"GI.Clutter.Objects.Actor#g:attr:pivotPoint\") instead"] #-}
-- | Gets the current anchor point of the /@actor@/ in pixels.
-- 
-- /Since: 0.6/
actorGetAnchorPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float))
actorGetAnchorPoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float)
actorGetAnchorPoint a
self = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
anchorX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
anchorY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_anchor_point Ptr Actor
self' Ptr CFloat
anchorX Ptr CFloat
anchorY
    CFloat
anchorX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
anchorX
    let anchorX'' :: Float
anchorX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
anchorX'
    CFloat
anchorY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
anchorY
    let anchorY'' :: Float
anchorY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
anchorY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
anchorX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
anchorY
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
anchorX'', Float
anchorY'')

#if defined(ENABLE_OVERLOADING)
data ActorGetAnchorPointMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetAnchorPointMethodInfo a signature where
    overloadedMethod = actorGetAnchorPoint

instance O.OverloadedMethodInfo ActorGetAnchorPointMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetAnchorPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetAnchorPoint"
        })


#endif

-- method Actor::get_anchor_point_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Gravity" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_anchor_point_gravity" clutter_actor_get_anchor_point_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

{-# DEPRECATED actorGetAnchorPointGravity ["(Since version 1.12)","Use [Actor:pivotPoint](\"GI.Clutter.Objects.Actor#g:attr:pivotPoint\") instead."] #-}
-- | Retrieves the anchor position expressed as a t'GI.Clutter.Enums.Gravity'. If
-- the anchor point was specified using pixels or units this will
-- return 'GI.Clutter.Enums.GravityNone'.
-- 
-- /Since: 1.0/
actorGetAnchorPointGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.Gravity
    -- ^ __Returns:__ the t'GI.Clutter.Enums.Gravity' used by the anchor point
actorGetAnchorPointGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Gravity
actorGetAnchorPointGravity a
self = IO Gravity -> m Gravity
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Gravity -> m Gravity) -> IO Gravity -> m Gravity
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_anchor_point_gravity Ptr Actor
self'
    let result' :: Gravity
result' = (Int -> Gravity
forall a. Enum a => Int -> a
toEnum (Int -> Gravity) -> (CUInt -> Int) -> CUInt -> Gravity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Gravity -> IO Gravity
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Gravity
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetAnchorPointGravityMethodInfo
instance (signature ~ (m Clutter.Enums.Gravity), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetAnchorPointGravityMethodInfo a signature where
    overloadedMethod = actorGetAnchorPointGravity

instance O.OverloadedMethodInfo ActorGetAnchorPointGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetAnchorPointGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetAnchorPointGravity"
        })


#endif

-- method Actor::get_animation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "Animation" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_animation" clutter_actor_get_animation :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Clutter.Animation.Animation)

{-# DEPRECATED actorGetAnimation ["(Since version 1.12)","Use the implicit transition for animatable properties","  in t'GI.Clutter.Objects.Actor.Actor' instead, and 'GI.Clutter.Objects.Actor.actorGetTransition' to retrieve","  the transition."] #-}
-- | Retrieves the t'GI.Clutter.Objects.Animation.Animation' used by /@actor@/, if @/clutter_actor_animate()/@
-- has been called on /@actor@/.
-- 
-- /Since: 1.0/
actorGetAnimation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Animation.Animation
    -- ^ __Returns:__ a t'GI.Clutter.Objects.Animation.Animation', or 'P.Nothing'
actorGetAnimation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Animation
actorGetAnimation a
actor = IO Animation -> m Animation
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Animation -> m Animation) -> IO Animation -> m Animation
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    Ptr Animation
result <- Ptr Actor -> IO (Ptr Animation)
clutter_actor_get_animation Ptr Actor
actor'
    Text -> Ptr Animation -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetAnimation" Ptr Animation
result
    Animation
result' <- ((ManagedPtr Animation -> Animation)
-> Ptr Animation -> IO Animation
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Animation -> Animation
Clutter.Animation.Animation) Ptr Animation
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    Animation -> IO Animation
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Animation
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetAnimationMethodInfo
instance (signature ~ (m Clutter.Animation.Animation), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetAnimationMethodInfo a signature where
    overloadedMethod = actorGetAnimation

instance O.OverloadedMethodInfo ActorGetAnimationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetAnimation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetAnimation"
        })


#endif

-- method Actor::get_background_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #ClutterColor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_background_color" clutter_actor_get_background_color :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO ()

-- | Retrieves the color set using 'GI.Clutter.Objects.Actor.actorSetBackgroundColor'.
-- 
-- /Since: 1.10/
actorGetBackgroundColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m (Clutter.Color.Color)
actorGetBackgroundColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Color
actorGetBackgroundColor a
self = IO Color -> m Color
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
4 :: IO (Ptr Clutter.Color.Color)
    Ptr Actor -> Ptr Color -> IO ()
clutter_actor_get_background_color Ptr Actor
self' Ptr Color
color
    Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Clutter.Color.Color) Ptr Color
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Color -> IO Color
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'

#if defined(ENABLE_OVERLOADING)
data ActorGetBackgroundColorMethodInfo
instance (signature ~ (m (Clutter.Color.Color)), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetBackgroundColorMethodInfo a signature where
    overloadedMethod = actorGetBackgroundColor

instance O.OverloadedMethodInfo ActorGetBackgroundColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetBackgroundColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetBackgroundColor"
        })


#endif

-- method Actor::get_child_at_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position in the list of children"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_child_at_index" clutter_actor_get_child_at_index :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Int32 ->                                -- index_ : TBasicType TInt
    IO (Ptr Actor)

-- | Retrieves the actor at the given /@index_@/ inside the list of
-- children of /@self@/.
-- 
-- /Since: 1.10/
actorGetChildAtIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Int32
    -- ^ /@index_@/: the position in the list of children
    -> m Actor
    -- ^ __Returns:__ a pointer to a t'GI.Clutter.Objects.Actor.Actor', or 'P.Nothing'
actorGetChildAtIndex :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Int32 -> m Actor
actorGetChildAtIndex a
self Int32
index_ = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
result <- Ptr Actor -> Int32 -> IO (Ptr Actor)
clutter_actor_get_child_at_index Ptr Actor
self' Int32
index_
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetChildAtIndex" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetChildAtIndexMethodInfo
instance (signature ~ (Int32 -> m Actor), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetChildAtIndexMethodInfo a signature where
    overloadedMethod = actorGetChildAtIndex

instance O.OverloadedMethodInfo ActorGetChildAtIndexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetChildAtIndex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetChildAtIndex"
        })


#endif

-- XXX Could not generate method Actor::get_child_transform
-- Not implemented: Don't know how to allocate "transform" of type TInterface (Name {namespace = "Clutter", name = "Matrix"})
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data ActorGetChildTransformMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getChildTransform" Actor) => O.OverloadedMethod ActorGetChildTransformMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "getChildTransform" Actor) => O.OverloadedMethodInfo ActorGetChildTransformMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Actor::get_children
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface Name { namespace = "Clutter" , name = "Actor" }))
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_children" clutter_actor_get_children :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr (GList (Ptr Actor)))

-- | Retrieves the list of children of /@self@/.
-- 
-- /Since: 1.10/
actorGetChildren ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m [Actor]
    -- ^ __Returns:__ A newly
    --   allocated t'GI.GLib.Structs.List.List' of t'GI.Clutter.Objects.Actor.Actor's. Use @/g_list_free()/@ when
    --   done.
actorGetChildren :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m [Actor]
actorGetChildren a
self = IO [Actor] -> m [Actor]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Actor] -> m [Actor]) -> IO [Actor] -> m [Actor]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr (GList (Ptr Actor))
result <- Ptr Actor -> IO (Ptr (GList (Ptr Actor)))
clutter_actor_get_children Ptr Actor
self'
    [Ptr Actor]
result' <- Ptr (GList (Ptr Actor)) -> IO [Ptr Actor]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Actor))
result
    [Actor]
result'' <- (Ptr Actor -> IO Actor) -> [Ptr Actor] -> IO [Actor]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) [Ptr Actor]
result'
    Ptr (GList (Ptr Actor)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Actor))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [Actor] -> IO [Actor]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Actor]
result''

#if defined(ENABLE_OVERLOADING)
data ActorGetChildrenMethodInfo
instance (signature ~ (m [Actor]), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetChildrenMethodInfo a signature where
    overloadedMethod = actorGetChildren

instance O.OverloadedMethodInfo ActorGetChildrenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetChildren",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetChildren"
        })


#endif

-- method Actor::get_clip
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xoff"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the X offset of\n  the clip rectangle, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "yoff"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the Y offset of\n  the clip rectangle, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the width of\n  the clip rectangle, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the height of\n  the clip rectangle, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_clip" clutter_actor_get_clip :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- xoff : TBasicType TFloat
    Ptr CFloat ->                           -- yoff : TBasicType TFloat
    Ptr CFloat ->                           -- width : TBasicType TFloat
    Ptr CFloat ->                           -- height : TBasicType TFloat
    IO ()

-- | Gets the clip area for /@self@/, if any is set.
-- 
-- /Since: 0.6/
actorGetClip ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float, Float, Float))
actorGetClip :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float, Float, Float)
actorGetClip a
self = IO (Float, Float, Float, Float) -> m (Float, Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float, Float) -> m (Float, Float, Float, Float))
-> IO (Float, Float, Float, Float)
-> m (Float, Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
xoff <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
yoff <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
width <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
height <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor
-> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_clip Ptr Actor
self' Ptr CFloat
xoff Ptr CFloat
yoff Ptr CFloat
width Ptr CFloat
height
    CFloat
xoff' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
xoff
    let xoff'' :: Float
xoff'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
xoff'
    CFloat
yoff' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
yoff
    let yoff'' :: Float
yoff'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
yoff'
    CFloat
width' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
width
    let width'' :: Float
width'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
width'
    CFloat
height' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
height
    let height'' :: Float
height'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
height'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
xoff
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
yoff
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
width
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
height
    (Float, Float, Float, Float) -> IO (Float, Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
xoff'', Float
yoff'', Float
width'', Float
height'')

#if defined(ENABLE_OVERLOADING)
data ActorGetClipMethodInfo
instance (signature ~ (m ((Float, Float, Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetClipMethodInfo a signature where
    overloadedMethod = actorGetClip

instance O.OverloadedMethodInfo ActorGetClipMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetClip",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetClip"
        })


#endif

-- method Actor::get_clip_to_allocation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_clip_to_allocation" clutter_actor_get_clip_to_allocation :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Retrieves the value set using 'GI.Clutter.Objects.Actor.actorSetClipToAllocation'
-- 
-- /Since: 1.4/
actorGetClipToAllocation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Actor.Actor' is clipped to its allocation
actorGetClipToAllocation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorGetClipToAllocation a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_get_clip_to_allocation Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetClipToAllocationMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetClipToAllocationMethodInfo a signature where
    overloadedMethod = actorGetClipToAllocation

instance O.OverloadedMethodInfo ActorGetClipToAllocationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetClipToAllocation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetClipToAllocation"
        })


#endif

-- method Actor::get_constraint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the constraint to retrieve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "Constraint" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_constraint" clutter_actor_get_constraint :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Clutter.Constraint.Constraint)

-- | Retrieves the t'GI.Clutter.Objects.Constraint.Constraint' with the given name in the list
-- of constraints applied to /@self@/
-- 
-- /Since: 1.4/
actorGetConstraint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the constraint to retrieve
    -> m Clutter.Constraint.Constraint
    -- ^ __Returns:__ a t'GI.Clutter.Objects.Constraint.Constraint' for the given
    --   name, or 'P.Nothing'. The returned t'GI.Clutter.Objects.Constraint.Constraint' is owned by the
    --   actor and it should not be unreferenced directly
actorGetConstraint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m Constraint
actorGetConstraint a
self Text
name = IO Constraint -> m Constraint
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Constraint -> m Constraint) -> IO Constraint -> m Constraint
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Constraint
result <- Ptr Actor -> CString -> IO (Ptr Constraint)
clutter_actor_get_constraint Ptr Actor
self' CString
name'
    Text -> Ptr Constraint -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetConstraint" Ptr Constraint
result
    Constraint
result' <- ((ManagedPtr Constraint -> Constraint)
-> Ptr Constraint -> IO Constraint
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Constraint -> Constraint
Clutter.Constraint.Constraint) Ptr Constraint
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Constraint -> IO Constraint
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Constraint
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetConstraintMethodInfo
instance (signature ~ (T.Text -> m Clutter.Constraint.Constraint), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetConstraintMethodInfo a signature where
    overloadedMethod = actorGetConstraint

instance O.OverloadedMethodInfo ActorGetConstraintMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetConstraint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetConstraint"
        })


#endif

-- method Actor::get_constraints
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface Name { namespace = "Clutter" , name = "Constraint" }))
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_constraints" clutter_actor_get_constraints :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr (GList (Ptr Clutter.Constraint.Constraint)))

-- | Retrieves the list of constraints applied to /@self@/
-- 
-- /Since: 1.4/
actorGetConstraints ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m [Clutter.Constraint.Constraint]
    -- ^ __Returns:__ a copy
    --   of the list of t'GI.Clutter.Objects.Constraint.Constraint's. The contents of the list are
    --   owned by the t'GI.Clutter.Objects.Actor.Actor'. Use @/g_list_free()/@ to free the resources
    --   allocated by the returned t'GI.GLib.Structs.List.List'
actorGetConstraints :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m [Constraint]
actorGetConstraints a
self = IO [Constraint] -> m [Constraint]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Constraint] -> m [Constraint])
-> IO [Constraint] -> m [Constraint]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr (GList (Ptr Constraint))
result <- Ptr Actor -> IO (Ptr (GList (Ptr Constraint)))
clutter_actor_get_constraints Ptr Actor
self'
    [Ptr Constraint]
result' <- Ptr (GList (Ptr Constraint)) -> IO [Ptr Constraint]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Constraint))
result
    [Constraint]
result'' <- (Ptr Constraint -> IO Constraint)
-> [Ptr Constraint] -> IO [Constraint]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr Constraint -> Constraint)
-> Ptr Constraint -> IO Constraint
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Constraint -> Constraint
Clutter.Constraint.Constraint) [Ptr Constraint]
result'
    Ptr (GList (Ptr Constraint)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Constraint))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [Constraint] -> IO [Constraint]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Constraint]
result''

#if defined(ENABLE_OVERLOADING)
data ActorGetConstraintsMethodInfo
instance (signature ~ (m [Clutter.Constraint.Constraint]), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetConstraintsMethodInfo a signature where
    overloadedMethod = actorGetConstraints

instance O.OverloadedMethodInfo ActorGetConstraintsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetConstraints",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetConstraints"
        })


#endif

-- method Actor::get_content
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Content" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_content" clutter_actor_get_content :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Clutter.Content.Content)

-- | Retrieves the contents of /@self@/.
-- 
-- /Since: 1.10/
actorGetContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Content.Content
    -- ^ __Returns:__ a pointer to the t'GI.Clutter.Interfaces.Content.Content' instance,
    --   or 'P.Nothing' if none was set
actorGetContent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Content
actorGetContent a
self = IO Content -> m Content
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Content -> m Content) -> IO Content -> m Content
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Content
result <- Ptr Actor -> IO (Ptr Content)
clutter_actor_get_content Ptr Actor
self'
    Text -> Ptr Content -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetContent" Ptr Content
result
    Content
result' <- ((ManagedPtr Content -> Content) -> Ptr Content -> IO Content
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Content -> Content
Clutter.Content.Content) Ptr Content
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Content -> IO Content
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Content
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetContentMethodInfo
instance (signature ~ (m Clutter.Content.Content), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetContentMethodInfo a signature where
    overloadedMethod = actorGetContent

instance O.OverloadedMethodInfo ActorGetContentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetContent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetContent"
        })


#endif

-- method Actor::get_content_box
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorBox" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the return location for the bounding\n  box for the #ClutterContent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_content_box" clutter_actor_get_content_box :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.ActorBox.ActorBox ->        -- box : TInterface (Name {namespace = "Clutter", name = "ActorBox"})
    IO ()

-- | Retrieves the bounding box for the t'GI.Clutter.Interfaces.Content.Content' of /@self@/.
-- 
-- The bounding box is relative to the actor\'s allocation.
-- 
-- If no t'GI.Clutter.Interfaces.Content.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 t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- If the t'GI.Clutter.Interfaces.Content.Content' used by the actor has a preferred size, then
-- it is possible to modify the content box by using the
-- [Actor:contentGravity]("GI.Clutter.Objects.Actor#g:attr:contentGravity") property.
-- 
-- /Since: 1.10/
actorGetContentBox ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m (Clutter.ActorBox.ActorBox)
actorGetContentBox :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ActorBox
actorGetContentBox a
self = IO ActorBox -> m ActorBox
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ActorBox -> m ActorBox) -> IO ActorBox -> m ActorBox
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActorBox
box <- Int -> IO (Ptr ActorBox)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.ActorBox.ActorBox)
    Ptr Actor -> Ptr ActorBox -> IO ()
clutter_actor_get_content_box Ptr Actor
self' Ptr ActorBox
box
    ActorBox
box' <- ((ManagedPtr ActorBox -> ActorBox) -> Ptr ActorBox -> IO ActorBox
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ActorBox -> ActorBox
Clutter.ActorBox.ActorBox) Ptr ActorBox
box
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ActorBox -> IO ActorBox
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ActorBox
box'

#if defined(ENABLE_OVERLOADING)
data ActorGetContentBoxMethodInfo
instance (signature ~ (m (Clutter.ActorBox.ActorBox)), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetContentBoxMethodInfo a signature where
    overloadedMethod = actorGetContentBox

instance O.OverloadedMethodInfo ActorGetContentBoxMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetContentBox",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetContentBox"
        })


#endif

-- method Actor::get_content_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "ContentGravity" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_content_gravity" clutter_actor_get_content_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves the content gravity as set using
-- 'GI.Clutter.Objects.Actor.actorSetContentGravity'.
-- 
-- /Since: 1.10/
actorGetContentGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.ContentGravity
    -- ^ __Returns:__ the content gravity
actorGetContentGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ContentGravity
actorGetContentGravity a
self = IO ContentGravity -> m ContentGravity
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ContentGravity -> m ContentGravity)
-> IO ContentGravity -> m ContentGravity
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_content_gravity Ptr Actor
self'
    let result' :: ContentGravity
result' = (Int -> ContentGravity
forall a. Enum a => Int -> a
toEnum (Int -> ContentGravity)
-> (CUInt -> Int) -> CUInt -> ContentGravity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ContentGravity -> IO ContentGravity
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ContentGravity
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetContentGravityMethodInfo
instance (signature ~ (m Clutter.Enums.ContentGravity), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetContentGravityMethodInfo a signature where
    overloadedMethod = actorGetContentGravity

instance O.OverloadedMethodInfo ActorGetContentGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetContentGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetContentGravity"
        })


#endif

-- method Actor::get_content_repeat
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "ContentRepeat" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_content_repeat" clutter_actor_get_content_repeat :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves the repeat policy for a t'GI.Clutter.Objects.Actor.Actor' set by
-- 'GI.Clutter.Objects.Actor.actorSetContentRepeat'.
-- 
-- /Since: 1.12/
actorGetContentRepeat ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m [Clutter.Flags.ContentRepeat]
    -- ^ __Returns:__ the content repeat policy
actorGetContentRepeat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m [ContentRepeat]
actorGetContentRepeat a
self = IO [ContentRepeat] -> m [ContentRepeat]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ContentRepeat] -> m [ContentRepeat])
-> IO [ContentRepeat] -> m [ContentRepeat]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_content_repeat Ptr Actor
self'
    let result' :: [ContentRepeat]
result' = CUInt -> [ContentRepeat]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [ContentRepeat] -> IO [ContentRepeat]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ContentRepeat]
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetContentRepeatMethodInfo
instance (signature ~ (m [Clutter.Flags.ContentRepeat]), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetContentRepeatMethodInfo a signature where
    overloadedMethod = actorGetContentRepeat

instance O.OverloadedMethodInfo ActorGetContentRepeatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetContentRepeat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetContentRepeat"
        })


#endif

-- method Actor::get_content_scaling_filters
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_filter"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ScalingFilter" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the minification\n  filter, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "mag_filter"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ScalingFilter" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the magnification\n  filter, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_content_scaling_filters" clutter_actor_get_content_scaling_filters :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CUInt ->                            -- min_filter : TInterface (Name {namespace = "Clutter", name = "ScalingFilter"})
    Ptr CUInt ->                            -- mag_filter : TInterface (Name {namespace = "Clutter", name = "ScalingFilter"})
    IO ()

-- | Retrieves the values set using 'GI.Clutter.Objects.Actor.actorSetContentScalingFilters'.
-- 
-- /Since: 1.10/
actorGetContentScalingFilters ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Clutter.Enums.ScalingFilter, Clutter.Enums.ScalingFilter))
actorGetContentScalingFilters :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (ScalingFilter, ScalingFilter)
actorGetContentScalingFilters a
self = IO (ScalingFilter, ScalingFilter)
-> m (ScalingFilter, ScalingFilter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (ScalingFilter, ScalingFilter)
 -> m (ScalingFilter, ScalingFilter))
-> IO (ScalingFilter, ScalingFilter)
-> m (ScalingFilter, ScalingFilter)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CUInt
minFilter <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    Ptr CUInt
magFilter <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    Ptr Actor -> Ptr CUInt -> Ptr CUInt -> IO ()
clutter_actor_get_content_scaling_filters Ptr Actor
self' Ptr CUInt
minFilter Ptr CUInt
magFilter
    CUInt
minFilter' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
minFilter
    let minFilter'' :: ScalingFilter
minFilter'' = (Int -> ScalingFilter
forall a. Enum a => Int -> a
toEnum (Int -> ScalingFilter) -> (CUInt -> Int) -> CUInt -> ScalingFilter
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
minFilter'
    CUInt
magFilter' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
magFilter
    let magFilter'' :: ScalingFilter
magFilter'' = (Int -> ScalingFilter
forall a. Enum a => Int -> a
toEnum (Int -> ScalingFilter) -> (CUInt -> Int) -> CUInt -> ScalingFilter
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
magFilter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
minFilter
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
magFilter
    (ScalingFilter, ScalingFilter) -> IO (ScalingFilter, ScalingFilter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ScalingFilter
minFilter'', ScalingFilter
magFilter'')

#if defined(ENABLE_OVERLOADING)
data ActorGetContentScalingFiltersMethodInfo
instance (signature ~ (m ((Clutter.Enums.ScalingFilter, Clutter.Enums.ScalingFilter))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetContentScalingFiltersMethodInfo a signature where
    overloadedMethod = actorGetContentScalingFilters

instance O.OverloadedMethodInfo ActorGetContentScalingFiltersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetContentScalingFilters",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetContentScalingFilters"
        })


#endif

-- method Actor::get_default_paint_volume
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "PaintVolume" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_default_paint_volume" clutter_actor_get_default_paint_volume :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Clutter.PaintVolume.PaintVolume)

-- | Retrieves the default paint volume for /@self@/.
-- 
-- This function provides the same t'GI.Clutter.Structs.PaintVolume.PaintVolume' that would be
-- computed by the default implementation inside t'GI.Clutter.Objects.Actor.Actor' of the
-- t'GI.Clutter.Structs.ActorClass.ActorClass'.@/get_paint_volume/@() virtual function.
-- 
-- This function should only be used by t'GI.Clutter.Objects.Actor.Actor' subclasses that
-- cannot chain up to the parent implementation when computing their
-- paint volume.
-- 
-- /Since: 1.10/
actorGetDefaultPaintVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.PaintVolume.PaintVolume
    -- ^ __Returns:__ a pointer to the default
    --   t'GI.Clutter.Structs.PaintVolume.PaintVolume', relative to the t'GI.Clutter.Objects.Actor.Actor', or 'P.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
    --   'GI.Clutter.Structs.PaintVolume.paintVolumeCopy'.
actorGetDefaultPaintVolume :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m PaintVolume
actorGetDefaultPaintVolume a
self = IO PaintVolume -> m PaintVolume
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PaintVolume -> m PaintVolume)
-> IO PaintVolume -> m PaintVolume
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr PaintVolume
result <- Ptr Actor -> IO (Ptr PaintVolume)
clutter_actor_get_default_paint_volume Ptr Actor
self'
    Text -> Ptr PaintVolume -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetDefaultPaintVolume" Ptr PaintVolume
result
    PaintVolume
result' <- ((ManagedPtr PaintVolume -> PaintVolume)
-> Ptr PaintVolume -> IO PaintVolume
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr PaintVolume -> PaintVolume
Clutter.PaintVolume.PaintVolume) Ptr PaintVolume
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    PaintVolume -> IO PaintVolume
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PaintVolume
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetDefaultPaintVolumeMethodInfo
instance (signature ~ (m Clutter.PaintVolume.PaintVolume), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetDefaultPaintVolumeMethodInfo a signature where
    overloadedMethod = actorGetDefaultPaintVolume

instance O.OverloadedMethodInfo ActorGetDefaultPaintVolumeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetDefaultPaintVolume",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetDefaultPaintVolume"
        })


#endif

-- method Actor::get_depth
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_depth" clutter_actor_get_depth :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

{-# DEPRECATED actorGetDepth ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.actorGetZPosition' instead."] #-}
-- | Retrieves the depth of /@self@/.
actorGetDepth ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the depth of the actor
actorGetDepth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetDepth a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_depth Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetDepthMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetDepthMethodInfo a signature where
    overloadedMethod = actorGetDepth

instance O.OverloadedMethodInfo ActorGetDepthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetDepth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetDepth"
        })


#endif

-- method Actor::get_easing_delay
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_easing_delay" clutter_actor_get_easing_delay :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO Word32

-- | Retrieves the delay that should be applied when tweening animatable
-- properties.
-- 
-- /Since: 1.10/
actorGetEasingDelay ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Word32
    -- ^ __Returns:__ a delay, in milliseconds
actorGetEasingDelay :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Word32
actorGetEasingDelay a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Actor -> IO Word32
clutter_actor_get_easing_delay Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ActorGetEasingDelayMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetEasingDelayMethodInfo a signature where
    overloadedMethod = actorGetEasingDelay

instance O.OverloadedMethodInfo ActorGetEasingDelayMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetEasingDelay",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetEasingDelay"
        })


#endif

-- method Actor::get_easing_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_easing_duration" clutter_actor_get_easing_duration :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO Word32

-- | Retrieves the duration of the tweening for animatable
-- properties of /@self@/ for the current easing state.
-- 
-- /Since: 1.10/
actorGetEasingDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Word32
    -- ^ __Returns:__ the duration of the tweening, in milliseconds
actorGetEasingDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Word32
actorGetEasingDuration a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Actor -> IO Word32
clutter_actor_get_easing_duration Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ActorGetEasingDurationMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetEasingDurationMethodInfo a signature where
    overloadedMethod = actorGetEasingDuration

instance O.OverloadedMethodInfo ActorGetEasingDurationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetEasingDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetEasingDuration"
        })


#endif

-- method Actor::get_easing_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "AnimationMode" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_easing_mode" clutter_actor_get_easing_mode :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves the easing mode for the tweening of animatable properties
-- of /@self@/ for the current easing state.
-- 
-- /Since: 1.10/
actorGetEasingMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.AnimationMode
    -- ^ __Returns:__ an easing mode
actorGetEasingMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m AnimationMode
actorGetEasingMode a
self = IO AnimationMode -> m AnimationMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AnimationMode -> m AnimationMode)
-> IO AnimationMode -> m AnimationMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_easing_mode Ptr Actor
self'
    let result' :: AnimationMode
result' = (Int -> AnimationMode
forall a. Enum a => Int -> a
toEnum (Int -> AnimationMode) -> (CUInt -> Int) -> CUInt -> AnimationMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    AnimationMode -> IO AnimationMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return AnimationMode
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetEasingModeMethodInfo
instance (signature ~ (m Clutter.Enums.AnimationMode), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetEasingModeMethodInfo a signature where
    overloadedMethod = actorGetEasingMode

instance O.OverloadedMethodInfo ActorGetEasingModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetEasingMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetEasingMode"
        })


#endif

-- method Actor::get_effect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the effect to retrieve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Effect" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_effect" clutter_actor_get_effect :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Clutter.Effect.Effect)

-- | Retrieves the t'GI.Clutter.Objects.Effect.Effect' with the given name in the list
-- of effects applied to /@self@/
-- 
-- /Since: 1.4/
actorGetEffect ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the effect to retrieve
    -> m Clutter.Effect.Effect
    -- ^ __Returns:__ a t'GI.Clutter.Objects.Effect.Effect' for the given
    --   name, or 'P.Nothing'. The returned t'GI.Clutter.Objects.Effect.Effect' is owned by the
    --   actor and it should not be unreferenced directly
actorGetEffect :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m Effect
actorGetEffect a
self Text
name = IO Effect -> m Effect
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Effect -> m Effect) -> IO Effect -> m Effect
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Effect
result <- Ptr Actor -> CString -> IO (Ptr Effect)
clutter_actor_get_effect Ptr Actor
self' CString
name'
    Text -> Ptr Effect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetEffect" Ptr Effect
result
    Effect
result' <- ((ManagedPtr Effect -> Effect) -> Ptr Effect -> IO Effect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Effect -> Effect
Clutter.Effect.Effect) Ptr Effect
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Effect -> IO Effect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Effect
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetEffectMethodInfo
instance (signature ~ (T.Text -> m Clutter.Effect.Effect), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetEffectMethodInfo a signature where
    overloadedMethod = actorGetEffect

instance O.OverloadedMethodInfo ActorGetEffectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetEffect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetEffect"
        })


#endif

-- method Actor::get_effects
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface Name { namespace = "Clutter" , name = "Effect" }))
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_effects" clutter_actor_get_effects :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr (GList (Ptr Clutter.Effect.Effect)))

-- | Retrieves the t'GI.Clutter.Objects.Effect.Effect's applied on /@self@/, if any
-- 
-- /Since: 1.4/
actorGetEffects ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m [Clutter.Effect.Effect]
    -- ^ __Returns:__ a list
    --   of t'GI.Clutter.Objects.Effect.Effect's, or 'P.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
actorGetEffects :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m [Effect]
actorGetEffects a
self = IO [Effect] -> m [Effect]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Effect] -> m [Effect]) -> IO [Effect] -> m [Effect]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr (GList (Ptr Effect))
result <- Ptr Actor -> IO (Ptr (GList (Ptr Effect)))
clutter_actor_get_effects Ptr Actor
self'
    [Ptr Effect]
result' <- Ptr (GList (Ptr Effect)) -> IO [Ptr Effect]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Effect))
result
    [Effect]
result'' <- (Ptr Effect -> IO Effect) -> [Ptr Effect] -> IO [Effect]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr Effect -> Effect) -> Ptr Effect -> IO Effect
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Effect -> Effect
Clutter.Effect.Effect) [Ptr Effect]
result'
    Ptr (GList (Ptr Effect)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Effect))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [Effect] -> IO [Effect]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Effect]
result''

#if defined(ENABLE_OVERLOADING)
data ActorGetEffectsMethodInfo
instance (signature ~ (m [Clutter.Effect.Effect]), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetEffectsMethodInfo a signature where
    overloadedMethod = actorGetEffects

instance O.OverloadedMethodInfo ActorGetEffectsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetEffects",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetEffects"
        })


#endif

-- method Actor::get_first_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_first_child" clutter_actor_get_first_child :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Actor)

-- | 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/
actorGetFirstChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Actor
    -- ^ __Returns:__ a pointer to a t'GI.Clutter.Objects.Actor.Actor', or 'P.Nothing'
actorGetFirstChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Actor
actorGetFirstChild a
self = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
result <- Ptr Actor -> IO (Ptr Actor)
clutter_actor_get_first_child Ptr Actor
self'
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetFirstChild" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetFirstChildMethodInfo
instance (signature ~ (m Actor), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetFirstChildMethodInfo a signature where
    overloadedMethod = actorGetFirstChild

instance O.OverloadedMethodInfo ActorGetFirstChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetFirstChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetFirstChild"
        })


#endif

-- method Actor::get_fixed_position_set
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_fixed_position_set" clutter_actor_get_fixed_position_set :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether an actor has a fixed position set (and will thus be
-- unaffected by any layout manager).
-- 
-- /Since: 0.8/
actorGetFixedPositionSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the fixed position is set on the actor
actorGetFixedPositionSet :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorGetFixedPositionSet a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_get_fixed_position_set Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetFixedPositionSetMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetFixedPositionSetMethodInfo a signature where
    overloadedMethod = actorGetFixedPositionSet

instance O.OverloadedMethodInfo ActorGetFixedPositionSetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetFixedPositionSet",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetFixedPositionSet"
        })


#endif

-- method Actor::get_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "ActorFlags" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_flags" clutter_actor_get_flags :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves the flags set on /@self@/
-- 
-- /Since: 1.0/
actorGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m [Clutter.Flags.ActorFlags]
    -- ^ __Returns:__ a bitwise or of t'GI.Clutter.Flags.ActorFlags' or 0
actorGetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m [ActorFlags]
actorGetFlags a
self = IO [ActorFlags] -> m [ActorFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ActorFlags] -> m [ActorFlags])
-> IO [ActorFlags] -> m [ActorFlags]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_flags Ptr Actor
self'
    let result' :: [ActorFlags]
result' = CUInt -> [ActorFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [ActorFlags] -> IO [ActorFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ActorFlags]
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetFlagsMethodInfo
instance (signature ~ (m [Clutter.Flags.ActorFlags]), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetFlagsMethodInfo a signature where
    overloadedMethod = actorGetFlags

instance O.OverloadedMethodInfo ActorGetFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetFlags"
        })


#endif

-- method Actor::get_geometry
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "geometry"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Geometry" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A location to store actors #ClutterGeometry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_geometry" clutter_actor_get_geometry :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Geometry.Geometry ->        -- geometry : TInterface (Name {namespace = "Clutter", name = "Geometry"})
    IO ()

{-# DEPRECATED actorGetGeometry ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorGetPosition' and","  'GI.Clutter.Objects.Actor.actorGetSize', or 'GI.Clutter.Objects.Actor.actorGetAllocationGeometry'","  instead."] #-}
-- | Gets the size and position of an actor relative to its parent
-- actor. This is the same as calling 'GI.Clutter.Objects.Actor.actorGetPosition' and
-- 'GI.Clutter.Objects.Actor.actorGetSize'. It tries to \"do what you mean\" and get the
-- requested size and position if the actor\'s allocation is invalid.
actorGetGeometry ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m (Clutter.Geometry.Geometry)
actorGetGeometry :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Geometry
actorGetGeometry a
self = IO Geometry -> m Geometry
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Geometry -> m Geometry) -> IO Geometry -> m Geometry
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Geometry
geometry <- Int -> IO (Ptr Geometry)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.Geometry.Geometry)
    Ptr Actor -> Ptr Geometry -> IO ()
clutter_actor_get_geometry Ptr Actor
self' Ptr Geometry
geometry
    Geometry
geometry' <- ((ManagedPtr Geometry -> Geometry) -> Ptr Geometry -> IO Geometry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Geometry -> Geometry
Clutter.Geometry.Geometry) Ptr Geometry
geometry
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Geometry -> IO Geometry
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Geometry
geometry'

#if defined(ENABLE_OVERLOADING)
data ActorGetGeometryMethodInfo
instance (signature ~ (m (Clutter.Geometry.Geometry)), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetGeometryMethodInfo a signature where
    overloadedMethod = actorGetGeometry

instance O.OverloadedMethodInfo ActorGetGeometryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetGeometry",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetGeometry"
        })


#endif

-- method Actor::get_gid
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_gid" clutter_actor_get_gid :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO Word32

{-# DEPRECATED actorGetGid ["(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/
actorGetGid ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Word32
    -- ^ __Returns:__ Globally unique value for this object instance.
actorGetGid :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Word32
actorGetGid a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Actor -> IO Word32
clutter_actor_get_gid Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ActorGetGidMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetGidMethodInfo a signature where
    overloadedMethod = actorGetGid

instance O.OverloadedMethodInfo ActorGetGidMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetGid",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetGid"
        })


#endif

-- method Actor::get_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_height" clutter_actor_get_height :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the height of a t'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorGetAllocationBox' to retrieve the
-- allocated size or 'GI.Clutter.Objects.Actor.actorGetPreferredHeight' to retrieve the
-- preferred height.
-- 
-- If an actor has a fixed height, for instance a height that has been
-- assigned using 'GI.Clutter.Objects.Actor.actorSetHeight', the height returned will
-- be the same value.
actorGetHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the height of the actor, in pixels
actorGetHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetHeight a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_height Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetHeightMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetHeightMethodInfo a signature where
    overloadedMethod = actorGetHeight

instance O.OverloadedMethodInfo ActorGetHeightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetHeight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetHeight"
        })


#endif

-- method Actor::get_last_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_last_child" clutter_actor_get_last_child :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Actor)

-- | 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/
actorGetLastChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Actor
    -- ^ __Returns:__ a pointer to a t'GI.Clutter.Objects.Actor.Actor', or 'P.Nothing'
actorGetLastChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Actor
actorGetLastChild a
self = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
result <- Ptr Actor -> IO (Ptr Actor)
clutter_actor_get_last_child Ptr Actor
self'
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetLastChild" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetLastChildMethodInfo
instance (signature ~ (m Actor), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetLastChildMethodInfo a signature where
    overloadedMethod = actorGetLastChild

instance O.OverloadedMethodInfo ActorGetLastChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetLastChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetLastChild"
        })


#endif

-- method Actor::get_layout_manager
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "LayoutManager" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_layout_manager" clutter_actor_get_layout_manager :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Clutter.LayoutManager.LayoutManager)

-- | Retrieves the t'GI.Clutter.Objects.LayoutManager.LayoutManager' used by /@self@/.
-- 
-- /Since: 1.10/
actorGetLayoutManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.LayoutManager.LayoutManager
    -- ^ __Returns:__ a pointer to the t'GI.Clutter.Objects.LayoutManager.LayoutManager',
    --   or 'P.Nothing'
actorGetLayoutManager :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m LayoutManager
actorGetLayoutManager a
self = IO LayoutManager -> m LayoutManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LayoutManager -> m LayoutManager)
-> IO LayoutManager -> m LayoutManager
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr LayoutManager
result <- Ptr Actor -> IO (Ptr LayoutManager)
clutter_actor_get_layout_manager Ptr Actor
self'
    Text -> Ptr LayoutManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetLayoutManager" Ptr LayoutManager
result
    LayoutManager
result' <- ((ManagedPtr LayoutManager -> LayoutManager)
-> Ptr LayoutManager -> IO LayoutManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr LayoutManager -> LayoutManager
Clutter.LayoutManager.LayoutManager) Ptr LayoutManager
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    LayoutManager -> IO LayoutManager
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LayoutManager
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetLayoutManagerMethodInfo
instance (signature ~ (m Clutter.LayoutManager.LayoutManager), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetLayoutManagerMethodInfo a signature where
    overloadedMethod = actorGetLayoutManager

instance O.OverloadedMethodInfo ActorGetLayoutManagerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetLayoutManager",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetLayoutManager"
        })


#endif

-- method Actor::get_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Margin" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #ClutterMargin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_margin" clutter_actor_get_margin :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Margin.Margin ->            -- margin : TInterface (Name {namespace = "Clutter", name = "Margin"})
    IO ()

-- | Retrieves all the components of the margin of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
actorGetMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m (Clutter.Margin.Margin)
actorGetMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Margin
actorGetMargin a
self = IO Margin -> m Margin
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Margin -> m Margin) -> IO Margin -> m Margin
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Margin
margin <- Int -> IO (Ptr Margin)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.Margin.Margin)
    Ptr Actor -> Ptr Margin -> IO ()
clutter_actor_get_margin Ptr Actor
self' Ptr Margin
margin
    Margin
margin' <- ((ManagedPtr Margin -> Margin) -> Ptr Margin -> IO Margin
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Margin -> Margin
Clutter.Margin.Margin) Ptr Margin
margin
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Margin -> IO Margin
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Margin
margin'

#if defined(ENABLE_OVERLOADING)
data ActorGetMarginMethodInfo
instance (signature ~ (m (Clutter.Margin.Margin)), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetMarginMethodInfo a signature where
    overloadedMethod = actorGetMargin

instance O.OverloadedMethodInfo ActorGetMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetMargin"
        })


#endif

-- method Actor::get_margin_bottom
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_margin_bottom" clutter_actor_get_margin_bottom :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the bottom margin of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
actorGetMarginBottom ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the bottom margin
actorGetMarginBottom :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetMarginBottom a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_margin_bottom Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetMarginBottomMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetMarginBottomMethodInfo a signature where
    overloadedMethod = actorGetMarginBottom

instance O.OverloadedMethodInfo ActorGetMarginBottomMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetMarginBottom",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetMarginBottom"
        })


#endif

-- method Actor::get_margin_left
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_margin_left" clutter_actor_get_margin_left :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the left margin of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
actorGetMarginLeft ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the left margin
actorGetMarginLeft :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetMarginLeft a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_margin_left Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetMarginLeftMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetMarginLeftMethodInfo a signature where
    overloadedMethod = actorGetMarginLeft

instance O.OverloadedMethodInfo ActorGetMarginLeftMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetMarginLeft",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetMarginLeft"
        })


#endif

-- method Actor::get_margin_right
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_margin_right" clutter_actor_get_margin_right :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the right margin of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
actorGetMarginRight ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the right margin
actorGetMarginRight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetMarginRight a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_margin_right Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetMarginRightMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetMarginRightMethodInfo a signature where
    overloadedMethod = actorGetMarginRight

instance O.OverloadedMethodInfo ActorGetMarginRightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetMarginRight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetMarginRight"
        })


#endif

-- method Actor::get_margin_top
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_margin_top" clutter_actor_get_margin_top :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the top margin of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
actorGetMarginTop ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the top margin
actorGetMarginTop :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetMarginTop a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_margin_top Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetMarginTopMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetMarginTopMethodInfo a signature where
    overloadedMethod = actorGetMarginTop

instance O.OverloadedMethodInfo ActorGetMarginTopMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetMarginTop",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetMarginTop"
        })


#endif

-- method Actor::get_n_children
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_n_children" clutter_actor_get_n_children :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO Int32

-- | Retrieves the number of children of /@self@/.
-- 
-- /Since: 1.10/
actorGetNChildren ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Int32
    -- ^ __Returns:__ the number of children of an actor
actorGetNChildren :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Int32
actorGetNChildren a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr Actor -> IO Int32
clutter_actor_get_n_children Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ActorGetNChildrenMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetNChildrenMethodInfo a signature where
    overloadedMethod = actorGetNChildren

instance O.OverloadedMethodInfo ActorGetNChildrenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetNChildren",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetNChildren"
        })


#endif

-- method Actor::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_name" clutter_actor_get_name :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CString

-- | Retrieves the name of /@self@/.
actorGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m T.Text
    -- ^ __Returns:__ the name of the actor, or 'P.Nothing'. The returned string is
    --   owned by the actor and should not be modified or freed.
actorGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Text
actorGetName a
self = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Actor -> IO CString
clutter_actor_get_name Ptr Actor
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetNameMethodInfo a signature where
    overloadedMethod = actorGetName

instance O.OverloadedMethodInfo ActorGetNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetName"
        })


#endif

-- method Actor::get_next_sibling
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_next_sibling" clutter_actor_get_next_sibling :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Actor)

-- | 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/
actorGetNextSibling ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Actor
    -- ^ __Returns:__ a pointer to a t'GI.Clutter.Objects.Actor.Actor', or 'P.Nothing'
actorGetNextSibling :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Actor
actorGetNextSibling a
self = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
result <- Ptr Actor -> IO (Ptr Actor)
clutter_actor_get_next_sibling Ptr Actor
self'
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetNextSibling" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetNextSiblingMethodInfo
instance (signature ~ (m Actor), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetNextSiblingMethodInfo a signature where
    overloadedMethod = actorGetNextSibling

instance O.OverloadedMethodInfo ActorGetNextSiblingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetNextSibling",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetNextSibling"
        })


#endif

-- method Actor::get_offscreen_redirect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "OffscreenRedirect" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_offscreen_redirect" clutter_actor_get_offscreen_redirect :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves whether to redirect the actor to an offscreen buffer, as
-- set by 'GI.Clutter.Objects.Actor.actorSetOffscreenRedirect'.
-- 
-- /Since: 1.8/
actorGetOffscreenRedirect ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m [Clutter.Flags.OffscreenRedirect]
    -- ^ __Returns:__ the value of the offscreen-redirect property of the actor
actorGetOffscreenRedirect :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m [OffscreenRedirect]
actorGetOffscreenRedirect a
self = IO [OffscreenRedirect] -> m [OffscreenRedirect]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [OffscreenRedirect] -> m [OffscreenRedirect])
-> IO [OffscreenRedirect] -> m [OffscreenRedirect]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_offscreen_redirect Ptr Actor
self'
    let result' :: [OffscreenRedirect]
result' = CUInt -> [OffscreenRedirect]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [OffscreenRedirect] -> IO [OffscreenRedirect]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [OffscreenRedirect]
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetOffscreenRedirectMethodInfo
instance (signature ~ (m [Clutter.Flags.OffscreenRedirect]), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetOffscreenRedirectMethodInfo a signature where
    overloadedMethod = actorGetOffscreenRedirect

instance O.OverloadedMethodInfo ActorGetOffscreenRedirectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetOffscreenRedirect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetOffscreenRedirect"
        })


#endif

-- method Actor::get_opacity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt8)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_opacity" clutter_actor_get_opacity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO Word8

-- | Retrieves the opacity value of an actor, as set by
-- 'GI.Clutter.Objects.Actor.actorSetOpacity'.
-- 
-- For retrieving the absolute opacity of the actor inside a paint
-- virtual function, see 'GI.Clutter.Objects.Actor.actorGetPaintOpacity'.
actorGetOpacity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Word8
    -- ^ __Returns:__ the opacity of the actor
actorGetOpacity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Word8
actorGetOpacity a
self = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word8
result <- Ptr Actor -> IO Word8
clutter_actor_get_opacity Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result

#if defined(ENABLE_OVERLOADING)
data ActorGetOpacityMethodInfo
instance (signature ~ (m Word8), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetOpacityMethodInfo a signature where
    overloadedMethod = actorGetOpacity

instance O.OverloadedMethodInfo ActorGetOpacityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetOpacity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetOpacity"
        })


#endif

-- method Actor::get_paint_box
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorBox" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #ClutterActorBox"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_paint_box" clutter_actor_get_paint_box :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.ActorBox.ActorBox ->        -- box : TInterface (Name {namespace = "Clutter", name = "ActorBox"})
    IO CInt

-- | Retrieves the paint volume of the passed t'GI.Clutter.Objects.Actor.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/
actorGetPaintBox ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Bool, Clutter.ActorBox.ActorBox))
    -- ^ __Returns:__ 'P.True' if a 2D paint box could be determined, else
    -- 'P.False'.
actorGetPaintBox :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Bool, ActorBox)
actorGetPaintBox a
self = IO (Bool, ActorBox) -> m (Bool, ActorBox)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, ActorBox) -> m (Bool, ActorBox))
-> IO (Bool, ActorBox) -> m (Bool, ActorBox)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActorBox
box <- Int -> IO (Ptr ActorBox)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.ActorBox.ActorBox)
    CInt
result <- Ptr Actor -> Ptr ActorBox -> IO CInt
clutter_actor_get_paint_box Ptr Actor
self' Ptr ActorBox
box
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    ActorBox
box' <- ((ManagedPtr ActorBox -> ActorBox) -> Ptr ActorBox -> IO ActorBox
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ActorBox -> ActorBox
Clutter.ActorBox.ActorBox) Ptr ActorBox
box
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    (Bool, ActorBox) -> IO (Bool, ActorBox)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', ActorBox
box')

#if defined(ENABLE_OVERLOADING)
data ActorGetPaintBoxMethodInfo
instance (signature ~ (m ((Bool, Clutter.ActorBox.ActorBox))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPaintBoxMethodInfo a signature where
    overloadedMethod = actorGetPaintBox

instance O.OverloadedMethodInfo ActorGetPaintBoxMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPaintBox",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPaintBox"
        })


#endif

-- method Actor::get_paint_opacity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt8)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_paint_opacity" clutter_actor_get_paint_opacity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO Word8

-- | 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/
actorGetPaintOpacity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Word8
    -- ^ __Returns:__ The actor opacity value.
actorGetPaintOpacity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Word8
actorGetPaintOpacity a
self = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word8
result <- Ptr Actor -> IO Word8
clutter_actor_get_paint_opacity Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result

#if defined(ENABLE_OVERLOADING)
data ActorGetPaintOpacityMethodInfo
instance (signature ~ (m Word8), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPaintOpacityMethodInfo a signature where
    overloadedMethod = actorGetPaintOpacity

instance O.OverloadedMethodInfo ActorGetPaintOpacityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPaintOpacity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPaintOpacity"
        })


#endif

-- method Actor::get_paint_visibility
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_paint_visibility" clutter_actor_get_paint_visibility :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | 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/
actorGetPaintVisibility ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor is visibile and will be painted.
actorGetPaintVisibility :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorGetPaintVisibility a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_get_paint_visibility Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetPaintVisibilityMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPaintVisibilityMethodInfo a signature where
    overloadedMethod = actorGetPaintVisibility

instance O.OverloadedMethodInfo ActorGetPaintVisibilityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPaintVisibility",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPaintVisibility"
        })


#endif

-- method Actor::get_paint_volume
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "PaintVolume" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_paint_volume" clutter_actor_get_paint_volume :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Clutter.PaintVolume.PaintVolume)

-- | Retrieves the paint volume of the passed t'GI.Clutter.Objects.Actor.Actor', or 'P.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 t'GI.Clutter.Structs.ActorClass.ActorClass'.@/get_paint_volume/@()
-- virtual function of the t'GI.Clutter.Objects.Actor.Actor' class. Sub-classes of t'GI.Clutter.Objects.Actor.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]("GI.Clutter.Objects.Actor#g:attr:depth") but real
-- 3D depth).
-- 
-- Note: 2D actors overriding t'GI.Clutter.Structs.ActorClass.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 'GI.Clutter.Structs.PaintVolume.paintVolumeSetDepth'.)
-- 
-- /Since: 1.6/
actorGetPaintVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.PaintVolume.PaintVolume
    -- ^ __Returns:__ a pointer to a t'GI.Clutter.Structs.PaintVolume.PaintVolume',
    --   or 'P.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 'GI.Clutter.Structs.PaintVolume.paintVolumeCopy'.
actorGetPaintVolume :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m PaintVolume
actorGetPaintVolume a
self = IO PaintVolume -> m PaintVolume
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PaintVolume -> m PaintVolume)
-> IO PaintVolume -> m PaintVolume
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr PaintVolume
result <- Ptr Actor -> IO (Ptr PaintVolume)
clutter_actor_get_paint_volume Ptr Actor
self'
    Text -> Ptr PaintVolume -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetPaintVolume" Ptr PaintVolume
result
    PaintVolume
result' <- ((ManagedPtr PaintVolume -> PaintVolume)
-> Ptr PaintVolume -> IO PaintVolume
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr PaintVolume -> PaintVolume
Clutter.PaintVolume.PaintVolume) Ptr PaintVolume
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    PaintVolume -> IO PaintVolume
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PaintVolume
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetPaintVolumeMethodInfo
instance (signature ~ (m Clutter.PaintVolume.PaintVolume), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPaintVolumeMethodInfo a signature where
    overloadedMethod = actorGetPaintVolume

instance O.OverloadedMethodInfo ActorGetPaintVolumeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPaintVolume",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPaintVolume"
        })


#endif

-- method Actor::get_pango_context
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "Context" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_pango_context" clutter_actor_get_pango_context :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Pango.Context.Context)

-- | Retrieves the t'GI.Pango.Objects.Context.Context' for /@self@/. The actor\'s t'GI.Pango.Objects.Context.Context'
-- is already configured using the appropriate font map, resolution
-- and font options.
-- 
-- Unlike 'GI.Clutter.Objects.Actor.actorCreatePangoContext', this context is owend
-- by the t'GI.Clutter.Objects.Actor.Actor' and it will be updated each time the options
-- stored by the t'GI.Clutter.Objects.Backend.Backend' change.
-- 
-- You can use the returned t'GI.Pango.Objects.Context.Context' to create a t'GI.Pango.Objects.Layout.Layout'
-- and render text using 'GI.CoglPango.Functions.renderLayout' to reuse the
-- glyphs cache also used by Clutter.
-- 
-- /Since: 1.0/
actorGetPangoContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Pango.Context.Context
    -- ^ __Returns:__ the t'GI.Pango.Objects.Context.Context' for a t'GI.Clutter.Objects.Actor.Actor'.
    --   The returned t'GI.Pango.Objects.Context.Context' is owned by the actor and should not be
    --   unreferenced by the application code
actorGetPangoContext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Context
actorGetPangoContext a
self = IO Context -> m Context
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Context -> m Context) -> IO Context -> m Context
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Context
result <- Ptr Actor -> IO (Ptr Context)
clutter_actor_get_pango_context Ptr Actor
self'
    Text -> Ptr Context -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetPangoContext" Ptr Context
result
    Context
result' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Context -> Context
Pango.Context.Context) Ptr Context
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Context -> IO Context
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Context
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetPangoContextMethodInfo
instance (signature ~ (m Pango.Context.Context), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPangoContextMethodInfo a signature where
    overloadedMethod = actorGetPangoContext

instance O.OverloadedMethodInfo ActorGetPangoContextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPangoContext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPangoContext"
        })


#endif

-- method Actor::get_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_parent" clutter_actor_get_parent :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Actor)

-- | Retrieves the parent of /@self@/.
actorGetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Actor
    -- ^ __Returns:__ The t'GI.Clutter.Objects.Actor.Actor' parent, or 'P.Nothing'
    --  if no parent is set
actorGetParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Actor
actorGetParent a
self = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
result <- Ptr Actor -> IO (Ptr Actor)
clutter_actor_get_parent Ptr Actor
self'
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetParent" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetParentMethodInfo
instance (signature ~ (m Actor), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetParentMethodInfo a signature where
    overloadedMethod = actorGetParent

instance O.OverloadedMethodInfo ActorGetParentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetParent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetParent"
        })


#endif

-- method Actor::get_pivot_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pivot_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the normalized X\n  coordinate of the pivot point, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "pivot_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the normalized Y\n  coordinate of the pivot point, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_pivot_point" clutter_actor_get_pivot_point :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- pivot_x : TBasicType TFloat
    Ptr CFloat ->                           -- pivot_y : TBasicType TFloat
    IO ()

-- | Retrieves the coordinates of the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- /Since: 1.12/
actorGetPivotPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float))
actorGetPivotPoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float)
actorGetPivotPoint a
self = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
pivotX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
pivotY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_pivot_point Ptr Actor
self' Ptr CFloat
pivotX Ptr CFloat
pivotY
    CFloat
pivotX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
pivotX
    let pivotX'' :: Float
pivotX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
pivotX'
    CFloat
pivotY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
pivotY
    let pivotY'' :: Float
pivotY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
pivotY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
pivotX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
pivotY
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
pivotX'', Float
pivotY'')

#if defined(ENABLE_OVERLOADING)
data ActorGetPivotPointMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPivotPointMethodInfo a signature where
    overloadedMethod = actorGetPivotPoint

instance O.OverloadedMethodInfo ActorGetPivotPointMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPivotPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPivotPoint"
        })


#endif

-- method Actor::get_pivot_point_z
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_pivot_point_z" clutter_actor_get_pivot_point_z :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the Z component of the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- /Since: 1.12/
actorGetPivotPointZ ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
actorGetPivotPointZ :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetPivotPointZ a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_pivot_point_z Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetPivotPointZMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPivotPointZMethodInfo a signature where
    overloadedMethod = actorGetPivotPointZ

instance O.OverloadedMethodInfo ActorGetPivotPointZMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPivotPointZ",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPivotPointZ"
        })


#endif

-- method Actor::get_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the X coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the Y coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_position" clutter_actor_get_position :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- x : TBasicType TFloat
    Ptr CFloat ->                           -- y : TBasicType TFloat
    IO ()

-- | 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/
actorGetPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float))
actorGetPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float)
actorGetPosition a
self = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
x <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
y <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_position Ptr Actor
self' Ptr CFloat
x Ptr CFloat
y
    CFloat
x' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
x
    let x'' :: Float
x'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x'
    CFloat
y' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
y
    let y'' :: Float
y'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
x
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
y
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
x'', Float
y'')

#if defined(ENABLE_OVERLOADING)
data ActorGetPositionMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPositionMethodInfo a signature where
    overloadedMethod = actorGetPosition

instance O.OverloadedMethodInfo ActorGetPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPosition"
        })


#endif

-- method Actor::get_preferred_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "for_width"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "available width to assume in computing desired height,\n  or a negative value to indicate that no width is defined"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_height_p"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for minimum height,\n  or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "natural_height_p"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for natural\n  height, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_preferred_height" clutter_actor_get_preferred_height :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- for_width : TBasicType TFloat
    Ptr CFloat ->                           -- min_height_p : TBasicType TFloat
    Ptr CFloat ->                           -- natural_height_p : TBasicType TFloat
    IO ()

-- | 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/
actorGetPreferredHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.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))
actorGetPreferredHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m (Float, Float)
actorGetPreferredHeight a
self Float
forWidth = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let forWidth' :: CFloat
forWidth' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
forWidth
    Ptr CFloat
minHeightP <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
naturalHeightP <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_preferred_height Ptr Actor
self' CFloat
forWidth' Ptr CFloat
minHeightP Ptr CFloat
naturalHeightP
    CFloat
minHeightP' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
minHeightP
    let minHeightP'' :: Float
minHeightP'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
minHeightP'
    CFloat
naturalHeightP' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
naturalHeightP
    let naturalHeightP'' :: Float
naturalHeightP'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
naturalHeightP'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
minHeightP
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
naturalHeightP
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
minHeightP'', Float
naturalHeightP'')

#if defined(ENABLE_OVERLOADING)
data ActorGetPreferredHeightMethodInfo
instance (signature ~ (Float -> m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPreferredHeightMethodInfo a signature where
    overloadedMethod = actorGetPreferredHeight

instance O.OverloadedMethodInfo ActorGetPreferredHeightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPreferredHeight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPreferredHeight"
        })


#endif

-- method Actor::get_preferred_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_width_p"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the minimum\n  width, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "min_height_p"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the minimum\n  height, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "natural_width_p"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the natural\n  width, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "natural_height_p"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the natural\n  height, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_preferred_size" clutter_actor_get_preferred_size :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- min_width_p : TBasicType TFloat
    Ptr CFloat ->                           -- min_height_p : TBasicType TFloat
    Ptr CFloat ->                           -- natural_width_p : TBasicType TFloat
    Ptr CFloat ->                           -- natural_height_p : TBasicType TFloat
    IO ()

-- | 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 'GI.Clutter.Objects.Actor.actorGetPreferredWidth'
-- and 'GI.Clutter.Objects.Actor.actorGetPreferredHeight', and check the actor\'s preferred
-- geometry management using the [Actor:requestMode]("GI.Clutter.Objects.Actor#g:attr:requestMode") property.
-- 
-- /Since: 0.8/
actorGetPreferredSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float, Float, Float))
actorGetPreferredSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float, Float, Float)
actorGetPreferredSize a
self = IO (Float, Float, Float, Float) -> m (Float, Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float, Float) -> m (Float, Float, Float, Float))
-> IO (Float, Float, Float, Float)
-> m (Float, Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
minWidthP <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
minHeightP <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
naturalWidthP <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
naturalHeightP <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor
-> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_preferred_size Ptr Actor
self' Ptr CFloat
minWidthP Ptr CFloat
minHeightP Ptr CFloat
naturalWidthP Ptr CFloat
naturalHeightP
    CFloat
minWidthP' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
minWidthP
    let minWidthP'' :: Float
minWidthP'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
minWidthP'
    CFloat
minHeightP' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
minHeightP
    let minHeightP'' :: Float
minHeightP'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
minHeightP'
    CFloat
naturalWidthP' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
naturalWidthP
    let naturalWidthP'' :: Float
naturalWidthP'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
naturalWidthP'
    CFloat
naturalHeightP' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
naturalHeightP
    let naturalHeightP'' :: Float
naturalHeightP'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
naturalHeightP'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
minWidthP
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
minHeightP
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
naturalWidthP
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
naturalHeightP
    (Float, Float, Float, Float) -> IO (Float, Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
minWidthP'', Float
minHeightP'', Float
naturalWidthP'', Float
naturalHeightP'')

#if defined(ENABLE_OVERLOADING)
data ActorGetPreferredSizeMethodInfo
instance (signature ~ (m ((Float, Float, Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPreferredSizeMethodInfo a signature where
    overloadedMethod = actorGetPreferredSize

instance O.OverloadedMethodInfo ActorGetPreferredSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPreferredSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPreferredSize"
        })


#endif

-- method Actor::get_preferred_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "for_height"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "available height when computing the preferred width,\n  or a negative value to indicate that no height is defined"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_width_p"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for minimum width,\n  or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "natural_width_p"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the natural\n  width, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_preferred_width" clutter_actor_get_preferred_width :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- for_height : TBasicType TFloat
    Ptr CFloat ->                           -- min_width_p : TBasicType TFloat
    Ptr CFloat ->                           -- natural_width_p : TBasicType TFloat
    IO ()

-- | 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/
actorGetPreferredWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@forHeight@/: available height when computing the preferred width,
    --   or a negative value to indicate that no height is defined
    -> m ((Float, Float))
actorGetPreferredWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m (Float, Float)
actorGetPreferredWidth a
self Float
forHeight = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let forHeight' :: CFloat
forHeight' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
forHeight
    Ptr CFloat
minWidthP <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
naturalWidthP <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_preferred_width Ptr Actor
self' CFloat
forHeight' Ptr CFloat
minWidthP Ptr CFloat
naturalWidthP
    CFloat
minWidthP' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
minWidthP
    let minWidthP'' :: Float
minWidthP'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
minWidthP'
    CFloat
naturalWidthP' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
naturalWidthP
    let naturalWidthP'' :: Float
naturalWidthP'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
naturalWidthP'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
minWidthP
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
naturalWidthP
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
minWidthP'', Float
naturalWidthP'')

#if defined(ENABLE_OVERLOADING)
data ActorGetPreferredWidthMethodInfo
instance (signature ~ (Float -> m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPreferredWidthMethodInfo a signature where
    overloadedMethod = actorGetPreferredWidth

instance O.OverloadedMethodInfo ActorGetPreferredWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPreferredWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPreferredWidth"
        })


#endif

-- method Actor::get_previous_sibling
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_previous_sibling" clutter_actor_get_previous_sibling :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Actor)

-- | 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/
actorGetPreviousSibling ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Actor
    -- ^ __Returns:__ a pointer to a t'GI.Clutter.Objects.Actor.Actor', or 'P.Nothing'
actorGetPreviousSibling :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Actor
actorGetPreviousSibling a
self = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
result <- Ptr Actor -> IO (Ptr Actor)
clutter_actor_get_previous_sibling Ptr Actor
self'
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetPreviousSibling" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Actor) Ptr Actor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetPreviousSiblingMethodInfo
instance (signature ~ (m Actor), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetPreviousSiblingMethodInfo a signature where
    overloadedMethod = actorGetPreviousSibling

instance O.OverloadedMethodInfo ActorGetPreviousSiblingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetPreviousSibling",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetPreviousSibling"
        })


#endif

-- method Actor::get_reactive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_reactive" clutter_actor_get_reactive :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether /@actor@/ is marked as reactive.
-- 
-- /Since: 0.6/
actorGetReactive ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor is reactive
actorGetReactive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorGetReactive a
actor = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_get_reactive Ptr Actor
actor'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetReactiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetReactiveMethodInfo a signature where
    overloadedMethod = actorGetReactive

instance O.OverloadedMethodInfo ActorGetReactiveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetReactive",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetReactive"
        })


#endif

-- method Actor::get_request_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "RequestMode" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_request_mode" clutter_actor_get_request_mode :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves the geometry request mode of /@self@/
-- 
-- /Since: 1.2/
actorGetRequestMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.RequestMode
    -- ^ __Returns:__ the request mode for the actor
actorGetRequestMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m RequestMode
actorGetRequestMode a
self = IO RequestMode -> m RequestMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RequestMode -> m RequestMode)
-> IO RequestMode -> m RequestMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_request_mode Ptr Actor
self'
    let result' :: RequestMode
result' = (Int -> RequestMode
forall a. Enum a => Int -> a
toEnum (Int -> RequestMode) -> (CUInt -> Int) -> CUInt -> RequestMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    RequestMode -> IO RequestMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RequestMode
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetRequestModeMethodInfo
instance (signature ~ (m Clutter.Enums.RequestMode), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetRequestModeMethodInfo a signature where
    overloadedMethod = actorGetRequestMode

instance O.OverloadedMethodInfo ActorGetRequestModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetRequestMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetRequestMode"
        })


#endif

-- method Actor::get_rotation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "axis"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "RotateAxis" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the axis of rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return value for the X coordinate of the center of rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return value for the Y coordinate of the center of rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "z"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return value for the Z coordinate of the center of rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_rotation" clutter_actor_get_rotation :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- axis : TInterface (Name {namespace = "Clutter", name = "RotateAxis"})
    Ptr CFloat ->                           -- x : TBasicType TFloat
    Ptr CFloat ->                           -- y : TBasicType TFloat
    Ptr CFloat ->                           -- z : TBasicType TFloat
    IO CDouble

{-# DEPRECATED actorGetRotation ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.actorGetRotationAngle' and","  'GI.Clutter.Objects.Actor.actorGetPivotPoint' instead."] #-}
-- | Retrieves the angle and center of rotation on the given axis,
-- set using 'GI.Clutter.Objects.Actor.actorSetRotation'.
-- 
-- /Since: 0.8/
actorGetRotation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.RotateAxis
    -- ^ /@axis@/: the axis of rotation
    -> m ((Double, Float, Float, Float))
    -- ^ __Returns:__ the angle of rotation
actorGetRotation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> RotateAxis -> m (Double, Float, Float, Float)
actorGetRotation a
self RotateAxis
axis = IO (Double, Float, Float, Float) -> m (Double, Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Float, Float, Float)
 -> m (Double, Float, Float, Float))
-> IO (Double, Float, Float, Float)
-> m (Double, Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let axis' :: CUInt
axis' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (RotateAxis -> Int) -> RotateAxis -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RotateAxis -> Int
forall a. Enum a => a -> Int
fromEnum) RotateAxis
axis
    Ptr CFloat
x <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
y <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
z <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    CDouble
result <- Ptr Actor
-> CUInt -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO CDouble
clutter_actor_get_rotation Ptr Actor
self' CUInt
axis' Ptr CFloat
x Ptr CFloat
y Ptr CFloat
z
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    CFloat
x' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
x
    let x'' :: Float
x'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x'
    CFloat
y' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
y
    let y'' :: Float
y'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y'
    CFloat
z' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
z
    let z'' :: Float
z'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
z'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
x
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
y
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
z
    (Double, Float, Float, Float) -> IO (Double, Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
result', Float
x'', Float
y'', Float
z'')

#if defined(ENABLE_OVERLOADING)
data ActorGetRotationMethodInfo
instance (signature ~ (Clutter.Enums.RotateAxis -> m ((Double, Float, Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetRotationMethodInfo a signature where
    overloadedMethod = actorGetRotation

instance O.OverloadedMethodInfo ActorGetRotationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetRotation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetRotation"
        })


#endif

-- method Actor::get_rotation_angle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "axis"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "RotateAxis" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the axis of the rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_rotation_angle" clutter_actor_get_rotation_angle :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- axis : TInterface (Name {namespace = "Clutter", name = "RotateAxis"})
    IO CDouble

-- | Retrieves the angle of rotation set by 'GI.Clutter.Objects.Actor.actorSetRotationAngle'.
-- 
-- /Since: 1.12/
actorGetRotationAngle ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.RotateAxis
    -- ^ /@axis@/: the axis of the rotation
    -> m Double
    -- ^ __Returns:__ the angle of rotation, in degrees
actorGetRotationAngle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> RotateAxis -> m Double
actorGetRotationAngle a
self RotateAxis
axis = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let axis' :: CUInt
axis' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (RotateAxis -> Int) -> RotateAxis -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RotateAxis -> Int
forall a. Enum a => a -> Int
fromEnum) RotateAxis
axis
    CDouble
result <- Ptr Actor -> CUInt -> IO CDouble
clutter_actor_get_rotation_angle Ptr Actor
self' CUInt
axis'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetRotationAngleMethodInfo
instance (signature ~ (Clutter.Enums.RotateAxis -> m Double), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetRotationAngleMethodInfo a signature where
    overloadedMethod = actorGetRotationAngle

instance O.OverloadedMethodInfo ActorGetRotationAngleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetRotationAngle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetRotationAngle"
        })


#endif

-- method Actor::get_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale_x"
--           , argType = TBasicType TDouble
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Location to store horizonal\n  scale factor, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "scale_y"
--           , argType = TBasicType TDouble
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Location to store vertical\n  scale factor, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_scale" clutter_actor_get_scale :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CDouble ->                          -- scale_x : TBasicType TDouble
    Ptr CDouble ->                          -- scale_y : TBasicType TDouble
    IO ()

-- | Retrieves an actors scale factors.
-- 
-- /Since: 0.2/
actorGetScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Double, Double))
actorGetScale :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Double, Double)
actorGetScale a
self = IO (Double, Double) -> m (Double, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Double) -> m (Double, Double))
-> IO (Double, Double) -> m (Double, Double)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CDouble
scaleX <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
    Ptr CDouble
scaleY <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
    Ptr Actor -> Ptr CDouble -> Ptr CDouble -> IO ()
clutter_actor_get_scale Ptr Actor
self' Ptr CDouble
scaleX Ptr CDouble
scaleY
    CDouble
scaleX' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
scaleX
    let scaleX'' :: Double
scaleX'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
scaleX'
    CDouble
scaleY' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
scaleY
    let scaleY'' :: Double
scaleY'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
scaleY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
scaleX
    Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
scaleY
    (Double, Double) -> IO (Double, Double)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
scaleX'', Double
scaleY'')

#if defined(ENABLE_OVERLOADING)
data ActorGetScaleMethodInfo
instance (signature ~ (m ((Double, Double))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetScaleMethodInfo a signature where
    overloadedMethod = actorGetScale

instance O.OverloadedMethodInfo ActorGetScaleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetScale"
        })


#endif

-- method Actor::get_scale_center
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "center_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Location to store the X position\n  of the scale center, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "center_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Location to store the Y position\n  of the scale center, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_scale_center" clutter_actor_get_scale_center :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- center_x : TBasicType TFloat
    Ptr CFloat ->                           -- center_y : TBasicType TFloat
    IO ()

{-# DEPRECATED actorGetScaleCenter ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.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
-- t'GI.Clutter.Enums.Gravity' this will calculate the pixel offset using the
-- current size of the actor.
-- 
-- /Since: 1.0/
actorGetScaleCenter ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float))
actorGetScaleCenter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float)
actorGetScaleCenter a
self = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
centerX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
centerY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_scale_center Ptr Actor
self' Ptr CFloat
centerX Ptr CFloat
centerY
    CFloat
centerX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
centerX
    let centerX'' :: Float
centerX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
centerX'
    CFloat
centerY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
centerY
    let centerY'' :: Float
centerY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
centerY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
centerX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
centerY
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
centerX'', Float
centerY'')

#if defined(ENABLE_OVERLOADING)
data ActorGetScaleCenterMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetScaleCenterMethodInfo a signature where
    overloadedMethod = actorGetScaleCenter

instance O.OverloadedMethodInfo ActorGetScaleCenterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetScaleCenter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetScaleCenter"
        })


#endif

-- method Actor::get_scale_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Gravity" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_scale_gravity" clutter_actor_get_scale_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

{-# DEPRECATED actorGetScaleGravity ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.actorGetPivotPoint' instead."] #-}
-- | Retrieves the scale center as a compass direction. If the scale
-- center was specified in pixels or units this will return
-- 'GI.Clutter.Enums.GravityNone'.
-- 
-- /Since: 1.0/
actorGetScaleGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.Gravity
    -- ^ __Returns:__ the scale gravity
actorGetScaleGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Gravity
actorGetScaleGravity a
self = IO Gravity -> m Gravity
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Gravity -> m Gravity) -> IO Gravity -> m Gravity
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_scale_gravity Ptr Actor
self'
    let result' :: Gravity
result' = (Int -> Gravity
forall a. Enum a => Int -> a
toEnum (Int -> Gravity) -> (CUInt -> Int) -> CUInt -> Gravity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Gravity -> IO Gravity
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Gravity
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetScaleGravityMethodInfo
instance (signature ~ (m Clutter.Enums.Gravity), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetScaleGravityMethodInfo a signature where
    overloadedMethod = actorGetScaleGravity

instance O.OverloadedMethodInfo ActorGetScaleGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetScaleGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetScaleGravity"
        })


#endif

-- method Actor::get_scale_z
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_scale_z" clutter_actor_get_scale_z :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CDouble

-- | Retrieves the scaling factor along the Z axis, as set using
-- 'GI.Clutter.Objects.Actor.actorSetScaleZ'.
-- 
-- /Since: 1.12/
actorGetScaleZ ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Double
    -- ^ __Returns:__ the scaling factor along the Z axis
actorGetScaleZ :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Double
actorGetScaleZ a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr Actor -> IO CDouble
clutter_actor_get_scale_z Ptr Actor
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetScaleZMethodInfo
instance (signature ~ (m Double), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetScaleZMethodInfo a signature where
    overloadedMethod = actorGetScaleZ

instance O.OverloadedMethodInfo ActorGetScaleZMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetScaleZ",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetScaleZ"
        })


#endif

-- method Actor::get_shader
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Shader" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_shader" clutter_actor_get_shader :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Clutter.Shader.Shader)

{-# DEPRECATED actorGetShader ["(Since version 1.8)","Use 'GI.Clutter.Objects.Actor.actorGetEffect' instead."] #-}
-- | Queries the currently set t'GI.Clutter.Objects.Shader.Shader' on /@self@/.
-- 
-- /Since: 0.6/
actorGetShader ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Shader.Shader
    -- ^ __Returns:__ The currently set t'GI.Clutter.Objects.Shader.Shader'
    --   or 'P.Nothing' if no shader is set.
actorGetShader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Shader
actorGetShader a
self = IO Shader -> m Shader
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Shader -> m Shader) -> IO Shader -> m Shader
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Shader
result <- Ptr Actor -> IO (Ptr Shader)
clutter_actor_get_shader Ptr Actor
self'
    Text -> Ptr Shader -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetShader" Ptr Shader
result
    Shader
result' <- ((ManagedPtr Shader -> Shader) -> Ptr Shader -> IO Shader
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Shader -> Shader
Clutter.Shader.Shader) Ptr Shader
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Shader -> IO Shader
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Shader
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetShaderMethodInfo
instance (signature ~ (m Clutter.Shader.Shader), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetShaderMethodInfo a signature where
    overloadedMethod = actorGetShader

instance O.OverloadedMethodInfo ActorGetShaderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetShader",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetShader"
        })


#endif

-- method Actor::get_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the width, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the height, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_size" clutter_actor_get_size :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- width : TBasicType TFloat
    Ptr CFloat ->                           -- height : TBasicType TFloat
    IO ()

-- | 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
-- 'GI.Clutter.Objects.Actor.actorGetAllocationBox' or
-- 'GI.Clutter.Objects.Actor.actorGetPreferredWidth'.
-- 
-- /Since: 0.2/
actorGetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float))
actorGetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float)
actorGetSize a
self = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
width <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
height <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_size Ptr Actor
self' Ptr CFloat
width Ptr CFloat
height
    CFloat
width' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
width
    let width'' :: Float
width'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
width'
    CFloat
height' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
height
    let height'' :: Float
height'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
height'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
width
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
height
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
width'', Float
height'')

#if defined(ENABLE_OVERLOADING)
data ActorGetSizeMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetSizeMethodInfo a signature where
    overloadedMethod = actorGetSize

instance O.OverloadedMethodInfo ActorGetSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetSize"
        })


#endif

-- method Actor::get_stage
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Stage" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_stage" clutter_actor_get_stage :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Clutter.Stage.Stage)

-- | Retrieves the t'GI.Clutter.Objects.Stage.Stage' where /@actor@/ is contained.
-- 
-- /Since: 0.8/
actorGetStage ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Stage.Stage
    -- ^ __Returns:__ the stage
    --   containing the actor, or 'P.Nothing'
actorGetStage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Stage
actorGetStage a
actor = IO Stage -> m Stage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Stage -> m Stage) -> IO Stage -> m Stage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    Ptr Stage
result <- Ptr Actor -> IO (Ptr Stage)
clutter_actor_get_stage Ptr Actor
actor'
    Text -> Ptr Stage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetStage" Ptr Stage
result
    Stage
result' <- ((ManagedPtr Stage -> Stage) -> Ptr Stage -> IO Stage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Stage -> Stage
Clutter.Stage.Stage) Ptr Stage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    Stage -> IO Stage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Stage
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetStageMethodInfo
instance (signature ~ (m Clutter.Stage.Stage), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetStageMethodInfo a signature where
    overloadedMethod = actorGetStage

instance O.OverloadedMethodInfo ActorGetStageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetStage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetStage"
        })


#endif

-- method Actor::get_text_direction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "TextDirection" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_text_direction" clutter_actor_get_text_direction :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves the value set using 'GI.Clutter.Objects.Actor.actorSetTextDirection'
-- 
-- If no text direction has been previously set, the default text
-- direction, as returned by 'GI.Clutter.Functions.getDefaultTextDirection', will
-- be returned instead
-- 
-- /Since: 1.2/
actorGetTextDirection ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.TextDirection
    -- ^ __Returns:__ the t'GI.Clutter.Enums.TextDirection' for the actor
actorGetTextDirection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m TextDirection
actorGetTextDirection a
self = IO TextDirection -> m TextDirection
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextDirection -> m TextDirection)
-> IO TextDirection -> m TextDirection
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_text_direction Ptr Actor
self'
    let result' :: TextDirection
result' = (Int -> TextDirection
forall a. Enum a => Int -> a
toEnum (Int -> TextDirection) -> (CUInt -> Int) -> CUInt -> TextDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    TextDirection -> IO TextDirection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextDirection
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetTextDirectionMethodInfo
instance (signature ~ (m Clutter.Enums.TextDirection), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetTextDirectionMethodInfo a signature where
    overloadedMethod = actorGetTextDirection

instance O.OverloadedMethodInfo ActorGetTextDirectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetTextDirection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetTextDirection"
        })


#endif

-- XXX Could not generate method Actor::get_transform
-- Not implemented: Don't know how to allocate "transform" of type TInterface (Name {namespace = "Clutter", name = "Matrix"})
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data ActorGetTransformMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getTransform" Actor) => O.OverloadedMethod ActorGetTransformMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "getTransform" Actor) => O.OverloadedMethodInfo ActorGetTransformMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- XXX Could not generate method Actor::get_transformation_matrix
-- Not implemented: Don't know how to allocate "matrix" of type TInterface (Name {namespace = "Clutter", name = "Matrix"})
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data ActorGetTransformationMatrixMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getTransformationMatrix" Actor) => O.OverloadedMethod ActorGetTransformationMatrixMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "getTransformationMatrix" Actor) => O.OverloadedMethodInfo ActorGetTransformationMatrixMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Actor::get_transformed_paint_volume
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "relative_to_ancestor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #ClutterActor that is an ancestor of @self\n   (or %NULL for the stage)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "PaintVolume" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_transformed_paint_volume" clutter_actor_get_transformed_paint_volume :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- relative_to_ancestor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO (Ptr Clutter.PaintVolume.PaintVolume)

-- | Retrieves the 3D paint volume of an actor like
-- 'GI.Clutter.Objects.Actor.actorGetPaintVolume' does (Please refer to the
-- documentation of 'GI.Clutter.Objects.Actor.actorGetPaintVolume' for more
-- details.) and it additionally transforms the paint volume into the
-- coordinate space of /@relativeToAncestor@/. (Or the stage if 'P.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 'GI.Clutter.Structs.PaintVolume.paintVolumeUnion'.
-- 
-- /Since: 1.6/
actorGetTransformedPaintVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@relativeToAncestor@/: A t'GI.Clutter.Objects.Actor.Actor' that is an ancestor of /@self@/
    --    (or 'P.Nothing' for the stage)
    -> m Clutter.PaintVolume.PaintVolume
    -- ^ __Returns:__ a pointer to a t'GI.Clutter.Structs.PaintVolume.PaintVolume',
    --   or 'P.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 'GI.Clutter.Structs.PaintVolume.paintVolumeCopy'.
actorGetTransformedPaintVolume :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> b -> m PaintVolume
actorGetTransformedPaintVolume a
self b
relativeToAncestor = IO PaintVolume -> m PaintVolume
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PaintVolume -> m PaintVolume)
-> IO PaintVolume -> m PaintVolume
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
relativeToAncestor' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
relativeToAncestor
    Ptr PaintVolume
result <- Ptr Actor -> Ptr Actor -> IO (Ptr PaintVolume)
clutter_actor_get_transformed_paint_volume Ptr Actor
self' Ptr Actor
relativeToAncestor'
    Text -> Ptr PaintVolume -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetTransformedPaintVolume" Ptr PaintVolume
result
    PaintVolume
result' <- ((ManagedPtr PaintVolume -> PaintVolume)
-> Ptr PaintVolume -> IO PaintVolume
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr PaintVolume -> PaintVolume
Clutter.PaintVolume.PaintVolume) Ptr PaintVolume
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
relativeToAncestor
    PaintVolume -> IO PaintVolume
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PaintVolume
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetTransformedPaintVolumeMethodInfo
instance (signature ~ (b -> m Clutter.PaintVolume.PaintVolume), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorGetTransformedPaintVolumeMethodInfo a signature where
    overloadedMethod = actorGetTransformedPaintVolume

instance O.OverloadedMethodInfo ActorGetTransformedPaintVolumeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetTransformedPaintVolume",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetTransformedPaintVolume"
        })


#endif

-- method Actor::get_transformed_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the X coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the Y coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_transformed_position" clutter_actor_get_transformed_position :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- x : TBasicType TFloat
    Ptr CFloat ->                           -- y : TBasicType TFloat
    IO ()

-- | Gets the absolute position of an actor, in pixels relative to the stage.
-- 
-- /Since: 0.8/
actorGetTransformedPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float))
actorGetTransformedPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float)
actorGetTransformedPosition a
self = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
x <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
y <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_transformed_position Ptr Actor
self' Ptr CFloat
x Ptr CFloat
y
    CFloat
x' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
x
    let x'' :: Float
x'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x'
    CFloat
y' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
y
    let y'' :: Float
y'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
x
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
y
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
x'', Float
y'')

#if defined(ENABLE_OVERLOADING)
data ActorGetTransformedPositionMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetTransformedPositionMethodInfo a signature where
    overloadedMethod = actorGetTransformedPosition

instance O.OverloadedMethodInfo ActorGetTransformedPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetTransformedPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetTransformedPosition"
        })


#endif

-- method Actor::get_transformed_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the width, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the height, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_transformed_size" clutter_actor_get_transformed_size :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- width : TBasicType TFloat
    Ptr CFloat ->                           -- height : TBasicType TFloat
    IO ()

-- | 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
-- 'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorGetTransformedPosition'; if you need this
-- information, you need to use 'GI.Clutter.Objects.Actor.actorGetAbsAllocationVertices'
-- to get the coords of the actual quadrangle.
-- 
-- /Since: 0.8/
actorGetTransformedSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float))
actorGetTransformedSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float)
actorGetTransformedSize a
self = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
width <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
height <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_transformed_size Ptr Actor
self' Ptr CFloat
width Ptr CFloat
height
    CFloat
width' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
width
    let width'' :: Float
width'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
width'
    CFloat
height' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
height
    let height'' :: Float
height'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
height'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
width
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
height
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
width'', Float
height'')

#if defined(ENABLE_OVERLOADING)
data ActorGetTransformedSizeMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetTransformedSizeMethodInfo a signature where
    overloadedMethod = actorGetTransformedSize

instance O.OverloadedMethodInfo ActorGetTransformedSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetTransformedSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetTransformedSize"
        })


#endif

-- method Actor::get_transition
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the transition"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "Transition" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_transition" clutter_actor_get_transition :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr Clutter.Transition.Transition)

-- | Retrieves the t'GI.Clutter.Objects.Transition.Transition' of a t'GI.Clutter.Objects.Actor.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 [Actor::transitionStopped]("GI.Clutter.Objects.Actor#g:signal:transitionStopped") signal, using the
-- transition name as the signal detail.
-- 
-- /Since: 1.10/
actorGetTransition ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the transition
    -> m Clutter.Transition.Transition
    -- ^ __Returns:__ a t'GI.Clutter.Objects.Transition.Transition', or 'P.Nothing' is none
    --   was found to match the passed name; the returned instance is owned
    --   by Clutter and it should not be freed
actorGetTransition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m Transition
actorGetTransition a
self Text
name = IO Transition -> m Transition
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transition -> m Transition) -> IO Transition -> m Transition
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Transition
result <- Ptr Actor -> CString -> IO (Ptr Transition)
clutter_actor_get_transition Ptr Actor
self' CString
name'
    Text -> Ptr Transition -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"actorGetTransition" Ptr Transition
result
    Transition
result' <- ((ManagedPtr Transition -> Transition)
-> Ptr Transition -> IO Transition
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Transition -> Transition
Clutter.Transition.Transition) Ptr Transition
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Transition -> IO Transition
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Transition
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetTransitionMethodInfo
instance (signature ~ (T.Text -> m Clutter.Transition.Transition), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetTransitionMethodInfo a signature where
    overloadedMethod = actorGetTransition

instance O.OverloadedMethodInfo ActorGetTransitionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetTransition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetTransition"
        })


#endif

-- method Actor::get_translation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "translate_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the X component\n  of the translation, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "translate_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the Y component\n  of the translation, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "translate_z"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the Z component\n  of the translation, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_translation" clutter_actor_get_translation :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr CFloat ->                           -- translate_x : TBasicType TFloat
    Ptr CFloat ->                           -- translate_y : TBasicType TFloat
    Ptr CFloat ->                           -- translate_z : TBasicType TFloat
    IO ()

-- | Retrieves the translation set using 'GI.Clutter.Objects.Actor.actorSetTranslation'.
-- 
-- /Since: 1.12/
actorGetTranslation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ((Float, Float, Float))
actorGetTranslation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m (Float, Float, Float)
actorGetTranslation a
self = IO (Float, Float, Float) -> m (Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float) -> m (Float, Float, Float))
-> IO (Float, Float, Float) -> m (Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
translateX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
translateY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
translateZ <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr Actor -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_actor_get_translation Ptr Actor
self' Ptr CFloat
translateX Ptr CFloat
translateY Ptr CFloat
translateZ
    CFloat
translateX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
translateX
    let translateX'' :: Float
translateX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
translateX'
    CFloat
translateY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
translateY
    let translateY'' :: Float
translateY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
translateY'
    CFloat
translateZ' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
translateZ
    let translateZ'' :: Float
translateZ'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
translateZ'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
translateX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
translateY
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
translateZ
    (Float, Float, Float) -> IO (Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
translateX'', Float
translateY'', Float
translateZ'')

#if defined(ENABLE_OVERLOADING)
data ActorGetTranslationMethodInfo
instance (signature ~ (m ((Float, Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetTranslationMethodInfo a signature where
    overloadedMethod = actorGetTranslation

instance O.OverloadedMethodInfo ActorGetTranslationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetTranslation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetTranslation"
        })


#endif

-- method Actor::get_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_width" clutter_actor_get_width :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the width of a t'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorGetAllocationBox' to retrieve the
-- allocated size or 'GI.Clutter.Objects.Actor.actorGetPreferredWidth' to retrieve the
-- preferred width.
-- 
-- If an actor has a fixed width, for instance a width that has been
-- assigned using 'GI.Clutter.Objects.Actor.actorSetWidth', the width returned will
-- be the same value.
actorGetWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the width of the actor, in pixels
actorGetWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetWidth a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_width Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetWidthMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetWidthMethodInfo a signature where
    overloadedMethod = actorGetWidth

instance O.OverloadedMethodInfo ActorGetWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetWidth"
        })


#endif

-- method Actor::get_x
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_x" clutter_actor_get_x :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the X coordinate of a t'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorSetX',
-- 'GI.Clutter.Objects.Actor.actorSetPosition' or 'GI.Clutter.Objects.Actor.actorSetGeometry', this
-- function will return that coordinate.
-- 
-- If both the allocation and a fixed position are missing, this function
-- will return 0.
actorGetX ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the X coordinate, in pixels, ignoring any
    --   transformation (i.e. scaling, rotation)
actorGetX :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetX a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_x Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetXMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetXMethodInfo a signature where
    overloadedMethod = actorGetX

instance O.OverloadedMethodInfo ActorGetXMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetX",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetX"
        })


#endif

-- method Actor::get_x_align
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "ActorAlign" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_x_align" clutter_actor_get_x_align :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves the horizontal alignment policy set using
-- 'GI.Clutter.Objects.Actor.actorSetXAlign'.
-- 
-- /Since: 1.10/
actorGetXAlign ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.ActorAlign
    -- ^ __Returns:__ the horizontal alignment policy.
actorGetXAlign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ActorAlign
actorGetXAlign a
self = IO ActorAlign -> m ActorAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ActorAlign -> m ActorAlign) -> IO ActorAlign -> m ActorAlign
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_x_align Ptr Actor
self'
    let result' :: ActorAlign
result' = (Int -> ActorAlign
forall a. Enum a => Int -> a
toEnum (Int -> ActorAlign) -> (CUInt -> Int) -> CUInt -> ActorAlign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ActorAlign -> IO ActorAlign
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ActorAlign
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetXAlignMethodInfo
instance (signature ~ (m Clutter.Enums.ActorAlign), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetXAlignMethodInfo a signature where
    overloadedMethod = actorGetXAlign

instance O.OverloadedMethodInfo ActorGetXAlignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetXAlign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetXAlign"
        })


#endif

-- method Actor::get_x_expand
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_x_expand" clutter_actor_get_x_expand :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Retrieves the value set with 'GI.Clutter.Objects.Actor.actorSetXExpand'.
-- 
-- See also: 'GI.Clutter.Objects.Actor.actorNeedsExpand'
-- 
-- /Since: 1.12/
actorGetXExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor has been set to expand
actorGetXExpand :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorGetXExpand a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_get_x_expand Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetXExpandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetXExpandMethodInfo a signature where
    overloadedMethod = actorGetXExpand

instance O.OverloadedMethodInfo ActorGetXExpandMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetXExpand",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetXExpand"
        })


#endif

-- method Actor::get_y
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_y" clutter_actor_get_y :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the Y coordinate of a t'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorSetY',
-- 'GI.Clutter.Objects.Actor.actorSetPosition' or 'GI.Clutter.Objects.Actor.actorSetGeometry', this
-- function will return that coordinate.
-- 
-- If both the allocation and a fixed position are missing, this function
-- will return 0.
actorGetY ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the Y coordinate, in pixels, ignoring any
    --   transformation (i.e. scaling, rotation)
actorGetY :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetY a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_y Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetYMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetYMethodInfo a signature where
    overloadedMethod = actorGetY

instance O.OverloadedMethodInfo ActorGetYMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetY",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetY"
        })


#endif

-- method Actor::get_y_align
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "ActorAlign" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_y_align" clutter_actor_get_y_align :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

-- | Retrieves the vertical alignment policy set using
-- 'GI.Clutter.Objects.Actor.actorSetYAlign'.
-- 
-- /Since: 1.10/
actorGetYAlign ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.ActorAlign
    -- ^ __Returns:__ the vertical alignment policy.
actorGetYAlign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ActorAlign
actorGetYAlign a
self = IO ActorAlign -> m ActorAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ActorAlign -> m ActorAlign) -> IO ActorAlign -> m ActorAlign
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_y_align Ptr Actor
self'
    let result' :: ActorAlign
result' = (Int -> ActorAlign
forall a. Enum a => Int -> a
toEnum (Int -> ActorAlign) -> (CUInt -> Int) -> CUInt -> ActorAlign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ActorAlign -> IO ActorAlign
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ActorAlign
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetYAlignMethodInfo
instance (signature ~ (m Clutter.Enums.ActorAlign), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetYAlignMethodInfo a signature where
    overloadedMethod = actorGetYAlign

instance O.OverloadedMethodInfo ActorGetYAlignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetYAlign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetYAlign"
        })


#endif

-- method Actor::get_y_expand
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_y_expand" clutter_actor_get_y_expand :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Retrieves the value set with 'GI.Clutter.Objects.Actor.actorSetYExpand'.
-- 
-- See also: 'GI.Clutter.Objects.Actor.actorNeedsExpand'
-- 
-- /Since: 1.12/
actorGetYExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor has been set to expand
actorGetYExpand :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorGetYExpand a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_get_y_expand Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetYExpandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetYExpandMethodInfo a signature where
    overloadedMethod = actorGetYExpand

instance O.OverloadedMethodInfo ActorGetYExpandMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetYExpand",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetYExpand"
        })


#endif

-- method Actor::get_z_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_z_position" clutter_actor_get_z_position :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CFloat

-- | Retrieves the actor\'s position on the Z axis.
-- 
-- /Since: 1.12/
actorGetZPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Float
    -- ^ __Returns:__ the position on the Z axis.
actorGetZPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Float
actorGetZPosition a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Actor -> IO CFloat
clutter_actor_get_z_position Ptr Actor
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetZPositionMethodInfo
instance (signature ~ (m Float), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetZPositionMethodInfo a signature where
    overloadedMethod = actorGetZPosition

instance O.OverloadedMethodInfo ActorGetZPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetZPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetZPosition"
        })


#endif

-- method Actor::get_z_rotation_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Gravity" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_get_z_rotation_gravity" clutter_actor_get_z_rotation_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CUInt

{-# DEPRECATED actorGetZRotationGravity ["(Since version 1.12)","Use the [Actor:pivotPoint](\"GI.Clutter.Objects.Actor#g:attr:pivotPoint\") instead of","  a t'GI.Clutter.Enums.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 'GI.Clutter.Enums.GravityNone'.
-- 
-- /Since: 1.0/
actorGetZRotationGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Clutter.Enums.Gravity
    -- ^ __Returns:__ the Z rotation center
actorGetZRotationGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Gravity
actorGetZRotationGravity a
self = IO Gravity -> m Gravity
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Gravity -> m Gravity) -> IO Gravity -> m Gravity
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Actor -> IO CUInt
clutter_actor_get_z_rotation_gravity Ptr Actor
self'
    let result' :: Gravity
result' = (Int -> Gravity
forall a. Enum a => Int -> a
toEnum (Int -> Gravity) -> (CUInt -> Int) -> CUInt -> Gravity
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Gravity -> IO Gravity
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Gravity
result'

#if defined(ENABLE_OVERLOADING)
data ActorGetZRotationGravityMethodInfo
instance (signature ~ (m Clutter.Enums.Gravity), MonadIO m, IsActor a) => O.OverloadedMethod ActorGetZRotationGravityMethodInfo a signature where
    overloadedMethod = actorGetZRotationGravity

instance O.OverloadedMethodInfo ActorGetZRotationGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGetZRotationGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGetZRotationGravity"
        })


#endif

-- method Actor::grab_key_focus
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_grab_key_focus" clutter_actor_grab_key_focus :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Sets the key focus of the t'GI.Clutter.Objects.Stage.Stage' including /@self@/
-- to this t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.0/
actorGrabKeyFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorGrabKeyFocus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorGrabKeyFocus a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_grab_key_focus Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorGrabKeyFocusMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorGrabKeyFocusMethodInfo a signature where
    overloadedMethod = actorGrabKeyFocus

instance O.OverloadedMethodInfo ActorGrabKeyFocusMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorGrabKeyFocus",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorGrabKeyFocus"
        })


#endif

-- method Actor::has_actions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_has_actions" clutter_actor_has_actions :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Returns whether the actor has any actions applied.
-- 
-- /Since: 1.10/
actorHasActions ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor has any actions,
    --   'P.False' otherwise
actorHasActions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorHasActions a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_has_actions Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorHasActionsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorHasActionsMethodInfo a signature where
    overloadedMethod = actorHasActions

instance O.OverloadedMethodInfo ActorHasActionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHasActions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHasActions"
        })


#endif

-- method Actor::has_allocation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_has_allocation" clutter_actor_has_allocation :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | 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 'P.False', then the actor will normally
-- be allocated before it is next drawn on the screen.
-- 
-- /Since: 1.4/
actorHasAllocation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor has an up-to-date allocation
actorHasAllocation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorHasAllocation a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_has_allocation Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorHasAllocationMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorHasAllocationMethodInfo a signature where
    overloadedMethod = actorHasAllocation

instance O.OverloadedMethodInfo ActorHasAllocationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHasAllocation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHasAllocation"
        })


#endif

-- method Actor::has_clip
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_has_clip" clutter_actor_has_clip :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Determines whether the actor has a clip area set or not.
-- 
-- /Since: 0.2/
actorHasClip ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor has a clip area set.
actorHasClip :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorHasClip a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_has_clip Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorHasClipMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorHasClipMethodInfo a signature where
    overloadedMethod = actorHasClip

instance O.OverloadedMethodInfo ActorHasClipMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHasClip",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHasClip"
        })


#endif

-- method Actor::has_constraints
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_has_constraints" clutter_actor_has_constraints :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Returns whether the actor has any constraints applied.
-- 
-- /Since: 1.10/
actorHasConstraints ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor has any constraints,
    --   'P.False' otherwise
actorHasConstraints :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorHasConstraints a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_has_constraints Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorHasConstraintsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorHasConstraintsMethodInfo a signature where
    overloadedMethod = actorHasConstraints

instance O.OverloadedMethodInfo ActorHasConstraintsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHasConstraints",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHasConstraints"
        })


#endif

-- method Actor::has_effects
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_has_effects" clutter_actor_has_effects :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Returns whether the actor has any effects applied.
-- 
-- /Since: 1.10/
actorHasEffects ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor has any effects,
    --   'P.False' otherwise
actorHasEffects :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorHasEffects a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_has_effects Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorHasEffectsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorHasEffectsMethodInfo a signature where
    overloadedMethod = actorHasEffects

instance O.OverloadedMethodInfo ActorHasEffectsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHasEffects",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHasEffects"
        })


#endif

-- method Actor::has_key_focus
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_has_key_focus" clutter_actor_has_key_focus :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether /@self@/ is the t'GI.Clutter.Objects.Actor.Actor' that has key focus
-- 
-- /Since: 1.4/
actorHasKeyFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor has key focus, and 'P.False' otherwise
actorHasKeyFocus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorHasKeyFocus a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_has_key_focus Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorHasKeyFocusMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorHasKeyFocusMethodInfo a signature where
    overloadedMethod = actorHasKeyFocus

instance O.OverloadedMethodInfo ActorHasKeyFocusMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHasKeyFocus",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHasKeyFocus"
        })


#endif

-- method Actor::has_overlaps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_has_overlaps" clutter_actor_has_overlaps :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | 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
-- t'GI.Clutter.Structs.ActorClass.ActorClass'.@/has_overlaps/@() virtual function. See
-- 'GI.Clutter.Objects.Actor.actorSetOffscreenRedirect' for more information.
-- 
-- /Since: 1.8/
actorHasOverlaps ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor may have overlapping primitives, and
    --   'P.False' otherwise
actorHasOverlaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorHasOverlaps a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_has_overlaps Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorHasOverlapsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorHasOverlapsMethodInfo a signature where
    overloadedMethod = actorHasOverlaps

instance O.OverloadedMethodInfo ActorHasOverlapsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHasOverlaps",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHasOverlaps"
        })


#endif

-- method Actor::has_pointer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_has_pointer" clutter_actor_has_pointer :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether an actor contains the pointer of a
-- t'GI.Clutter.Objects.InputDevice.InputDevice'
-- 
-- /Since: 1.2/
actorHasPointer ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor contains the pointer, and
    --   'P.False' otherwise
actorHasPointer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorHasPointer a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_has_pointer Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorHasPointerMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorHasPointerMethodInfo a signature where
    overloadedMethod = actorHasPointer

instance O.OverloadedMethodInfo ActorHasPointerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHasPointer",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHasPointer"
        })


#endif

-- method Actor::hide
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_hide" clutter_actor_hide :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | 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:showOnSetParent]("GI.Clutter.Objects.Actor#g:attr:showOnSetParent") property will be set to 'P.False'
-- as a side-effect.
actorHide ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorHide :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorHide a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_hide Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorHideMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorHideMethodInfo a signature where
    overloadedMethod = actorHide

instance O.OverloadedMethodInfo ActorHideMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHide",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHide"
        })


#endif

-- method Actor::hide_all
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_hide_all" clutter_actor_hide_all :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorHideAll ["(Since version 1.10)","Using 'GI.Clutter.Objects.Actor.actorHide' on the actor will","  prevent its children from being painted as well."] #-}
-- | Calls 'GI.Clutter.Objects.Actor.actorHide' on all child actors (if any).
-- 
-- /Since: 0.2/
actorHideAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorHideAll :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorHideAll a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_hide_all Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorHideAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorHideAllMethodInfo a signature where
    overloadedMethod = actorHideAll

instance O.OverloadedMethodInfo ActorHideAllMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorHideAll",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorHideAll"
        })


#endif

-- method Actor::insert_child_above
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sibling"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child of @self, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_insert_child_above" clutter_actor_insert_child_above :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- sibling : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Inserts /@child@/ into the list of children of /@self@/, above another
-- child of /@self@/ or, if /@sibling@/ is 'P.Nothing', above all the children
-- of /@self@/.
-- 
-- This function will acquire a reference on /@child@/ that will only
-- be released when calling 'GI.Clutter.Objects.Actor.actorRemoveChild'.
-- 
-- This function will not take into consideration the [Actor:depth]("GI.Clutter.Objects.Actor#g:attr:depth")
-- of /@child@/.
-- 
-- This function will emit the [Container::actorAdded]("GI.Clutter.Interfaces.Container#g:signal:actorAdded") signal
-- on /@self@/.
-- 
-- /Since: 1.10/
actorInsertChildAbove ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@child@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (c)
    -- ^ /@sibling@/: a child of /@self@/, or 'P.Nothing'
    -> m ()
actorInsertChildAbove :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
a -> b -> Maybe c -> m ()
actorInsertChildAbove a
self b
child Maybe c
sibling = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
child' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Actor
maybeSibling <- case Maybe c
sibling of
        Maybe c
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
        Just c
jSibling -> do
            Ptr Actor
jSibling' <- c -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSibling
            Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jSibling'
    Ptr Actor -> Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_insert_child_above Ptr Actor
self' Ptr Actor
child' Ptr Actor
maybeSibling
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorInsertChildAboveMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsActor a, IsActor b, IsActor c) => O.OverloadedMethod ActorInsertChildAboveMethodInfo a signature where
    overloadedMethod = actorInsertChildAbove

instance O.OverloadedMethodInfo ActorInsertChildAboveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorInsertChildAbove",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorInsertChildAbove"
        })


#endif

-- method Actor::insert_child_at_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the index" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_insert_child_at_index" clutter_actor_insert_child_at_index :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Int32 ->                                -- index_ : TBasicType TInt
    IO ()

-- | 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 'GI.Clutter.Objects.Actor.actorRemoveChild'.
-- 
-- This function will not take into consideration the [Actor:depth]("GI.Clutter.Objects.Actor#g:attr:depth")
-- of /@child@/.
-- 
-- This function will emit the [Container::actorAdded]("GI.Clutter.Interfaces.Container#g:signal:actorAdded") signal
-- on /@self@/.
-- 
-- /Since: 1.10/
actorInsertChildAtIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@child@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Int32
    -- ^ /@index_@/: the index
    -> m ()
actorInsertChildAtIndex :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> b -> Int32 -> m ()
actorInsertChildAtIndex a
self b
child Int32
index_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
child' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Actor -> Ptr Actor -> Int32 -> IO ()
clutter_actor_insert_child_at_index Ptr Actor
self' Ptr Actor
child' Int32
index_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorInsertChildAtIndexMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorInsertChildAtIndexMethodInfo a signature where
    overloadedMethod = actorInsertChildAtIndex

instance O.OverloadedMethodInfo ActorInsertChildAtIndexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorInsertChildAtIndex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorInsertChildAtIndex"
        })


#endif

-- method Actor::insert_child_below
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sibling"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child of @self, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_insert_child_below" clutter_actor_insert_child_below :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- sibling : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Inserts /@child@/ into the list of children of /@self@/, below another
-- child of /@self@/ or, if /@sibling@/ is 'P.Nothing', below all the children
-- of /@self@/.
-- 
-- This function will acquire a reference on /@child@/ that will only
-- be released when calling 'GI.Clutter.Objects.Actor.actorRemoveChild'.
-- 
-- This function will not take into consideration the [Actor:depth]("GI.Clutter.Objects.Actor#g:attr:depth")
-- of /@child@/.
-- 
-- This function will emit the [Container::actorAdded]("GI.Clutter.Interfaces.Container#g:signal:actorAdded") signal
-- on /@self@/.
-- 
-- /Since: 1.10/
actorInsertChildBelow ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@child@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (c)
    -- ^ /@sibling@/: a child of /@self@/, or 'P.Nothing'
    -> m ()
actorInsertChildBelow :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
a -> b -> Maybe c -> m ()
actorInsertChildBelow a
self b
child Maybe c
sibling = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
child' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Actor
maybeSibling <- case Maybe c
sibling of
        Maybe c
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
        Just c
jSibling -> do
            Ptr Actor
jSibling' <- c -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSibling
            Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jSibling'
    Ptr Actor -> Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_insert_child_below Ptr Actor
self' Ptr Actor
child' Ptr Actor
maybeSibling
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorInsertChildBelowMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsActor a, IsActor b, IsActor c) => O.OverloadedMethod ActorInsertChildBelowMethodInfo a signature where
    overloadedMethod = actorInsertChildBelow

instance O.OverloadedMethodInfo ActorInsertChildBelowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorInsertChildBelow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorInsertChildBelow"
        })


#endif

-- method Actor::is_in_clone_paint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_is_in_clone_paint" clutter_actor_is_in_clone_paint :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether /@self@/ is being currently painted by a t'GI.Clutter.Objects.Clone.Clone'
-- 
-- This function is useful only inside the [paint](#g:signal:paint) virtual function
-- implementations or within handlers for the [Actor::paint]("GI.Clutter.Objects.Actor#g:signal:paint")
-- signal
-- 
-- This function should not be used by applications
-- 
-- /Since: 1.0/
actorIsInClonePaint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Actor.Actor' is currently being painted
    --   by a t'GI.Clutter.Objects.Clone.Clone', and 'P.False' otherwise
actorIsInClonePaint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorIsInClonePaint a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_is_in_clone_paint Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorIsInClonePaintMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorIsInClonePaintMethodInfo a signature where
    overloadedMethod = actorIsInClonePaint

instance O.OverloadedMethodInfo ActorIsInClonePaintMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorIsInClonePaint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorIsInClonePaint"
        })


#endif

-- method Actor::is_mapped
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_is_mapped" clutter_actor_is_mapped :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether a t'GI.Clutter.Objects.Actor.Actor' has been set as mapped.
-- 
-- See also @/CLUTTER_ACTOR_IS_MAPPED/@ and [Actor:mapped]("GI.Clutter.Objects.Actor#g:attr:mapped")
-- 
-- /Since: 1.24/
actorIsMapped ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor is mapped
actorIsMapped :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorIsMapped a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_is_mapped Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorIsMappedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorIsMappedMethodInfo a signature where
    overloadedMethod = actorIsMapped

instance O.OverloadedMethodInfo ActorIsMappedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorIsMapped",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorIsMapped"
        })


#endif

-- method Actor::is_realized
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_is_realized" clutter_actor_is_realized :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether a t'GI.Clutter.Objects.Actor.Actor' is realized.
-- 
-- See also @/CLUTTER_ACTOR_IS_REALIZED/@ and [Actor:realized]("GI.Clutter.Objects.Actor#g:attr:realized").
-- 
-- /Since: 1.24/
actorIsRealized ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor is realized
actorIsRealized :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorIsRealized a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_is_realized Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorIsRealizedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorIsRealizedMethodInfo a signature where
    overloadedMethod = actorIsRealized

instance O.OverloadedMethodInfo ActorIsRealizedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorIsRealized",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorIsRealized"
        })


#endif

-- method Actor::is_rotated
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_is_rotated" clutter_actor_is_rotated :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether any rotation is applied to the actor.
-- 
-- /Since: 0.6/
actorIsRotated ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor is rotated.
actorIsRotated :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorIsRotated a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_is_rotated Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorIsRotatedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorIsRotatedMethodInfo a signature where
    overloadedMethod = actorIsRotated

instance O.OverloadedMethodInfo ActorIsRotatedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorIsRotated",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorIsRotated"
        })


#endif

-- method Actor::is_scaled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_is_scaled" clutter_actor_is_scaled :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether the actor is scaled in either dimension.
-- 
-- /Since: 0.6/
actorIsScaled ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor is scaled.
actorIsScaled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorIsScaled a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_is_scaled Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorIsScaledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorIsScaledMethodInfo a signature where
    overloadedMethod = actorIsScaled

instance O.OverloadedMethodInfo ActorIsScaledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorIsScaled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorIsScaled"
        })


#endif

-- method Actor::is_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_is_visible" clutter_actor_is_visible :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Checks whether an actor is marked as visible.
-- 
-- See also @/CLUTTER_ACTOR_IS_VISIBLE/@ and [Actor:visible]("GI.Clutter.Objects.Actor#g:attr:visible").
-- 
-- /Since: 1.24/
actorIsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor visible
actorIsVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorIsVisible a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_is_visible Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorIsVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorIsVisibleMethodInfo a signature where
    overloadedMethod = actorIsVisible

instance O.OverloadedMethodInfo ActorIsVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorIsVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorIsVisible"
        })


#endif

-- method Actor::lower
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "above"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor to lower below"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_lower" clutter_actor_lower :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- above : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorLower ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorSetChildBelowSibling' instead."] #-}
-- | Puts /@self@/ below /@above@/.
-- 
-- Both actors must have the same parent, and the parent must implement
-- the t'GI.Clutter.Interfaces.Container.Container' interface.
-- 
-- This function calls 'GI.Clutter.Interfaces.Container.containerLowerChild' internally.
actorLower ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (b)
    -- ^ /@above@/: A t'GI.Clutter.Objects.Actor.Actor' to lower below
    -> m ()
actorLower :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> Maybe b -> m ()
actorLower a
self Maybe b
above = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
maybeAbove <- case Maybe b
above of
        Maybe b
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
        Just b
jAbove -> do
            Ptr Actor
jAbove' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jAbove
            Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jAbove'
    Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_lower Ptr Actor
self' Ptr Actor
maybeAbove
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
above b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorLowerMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorLowerMethodInfo a signature where
    overloadedMethod = actorLower

instance O.OverloadedMethodInfo ActorLowerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorLower",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorLower"
        })


#endif

-- method Actor::lower_bottom
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_lower_bottom" clutter_actor_lower_bottom :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorLowerBottom ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorSetChildBelowSibling' with","  a 'P.Nothing' sibling, instead."] #-}
-- | Lowers /@self@/ to the bottom.
-- 
-- This function calls 'GI.Clutter.Objects.Actor.actorLower' internally.
actorLowerBottom ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorLowerBottom :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorLowerBottom a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_lower_bottom Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorLowerBottomMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorLowerBottomMethodInfo a signature where
    overloadedMethod = actorLowerBottom

instance O.OverloadedMethodInfo ActorLowerBottomMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorLowerBottom",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorLowerBottom"
        })


#endif

-- method Actor::map
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_map" clutter_actor_map :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Sets the 'GI.Clutter.Flags.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 t'GI.Clutter.Structs.ActorClass.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/
actorMap ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorMap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorMap a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_map Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorMapMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorMapMethodInfo a signature where
    overloadedMethod = actorMap

instance O.OverloadedMethodInfo ActorMapMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorMap",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorMap"
        })


#endif

-- method Actor::move_anchor_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "anchor_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "X coordinate of the anchor point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "anchor_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Y coordinate of the anchor point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_move_anchor_point" clutter_actor_move_anchor_point :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- anchor_x : TBasicType TFloat
    CFloat ->                               -- anchor_y : TBasicType TFloat
    IO ()

{-# DEPRECATED actorMoveAnchorPoint ["(Since version 1.12)","Use [Actor:pivotPoint](\"GI.Clutter.Objects.Actor#g:attr:pivotPoint\") and","'GI.Clutter.Objects.Actor.actorSetTranslation' 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/
actorMoveAnchorPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@anchorX@/: X coordinate of the anchor point
    -> Float
    -- ^ /@anchorY@/: Y coordinate of the anchor point
    -> m ()
actorMoveAnchorPoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> m ()
actorMoveAnchorPoint a
self Float
anchorX Float
anchorY = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let anchorX' :: CFloat
anchorX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
anchorX
    let anchorY' :: CFloat
anchorY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
anchorY
    Ptr Actor -> CFloat -> CFloat -> IO ()
clutter_actor_move_anchor_point Ptr Actor
self' CFloat
anchorX' CFloat
anchorY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorMoveAnchorPointMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorMoveAnchorPointMethodInfo a signature where
    overloadedMethod = actorMoveAnchorPoint

instance O.OverloadedMethodInfo ActorMoveAnchorPointMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorMoveAnchorPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorMoveAnchorPoint"
        })


#endif

-- method Actor::move_anchor_point_from_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gravity"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Gravity" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#ClutterGravity." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_move_anchor_point_from_gravity" clutter_actor_move_anchor_point_from_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- gravity : TInterface (Name {namespace = "Clutter", name = "Gravity"})
    IO ()

{-# DEPRECATED actorMoveAnchorPointFromGravity ["(Since version 1.12)","Use [Actor:pivotPoint](\"GI.Clutter.Objects.Actor#g:attr:pivotPoint\") and","'GI.Clutter.Objects.Actor.actorSetTranslation' 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 'GI.Clutter.Enums.GravitySouthEast'
-- and later double the size of the actor, the anchor point will move
-- to the bottom right.
-- 
-- /Since: 0.6/
actorMoveAnchorPointFromGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.Gravity
    -- ^ /@gravity@/: t'GI.Clutter.Enums.Gravity'.
    -> m ()
actorMoveAnchorPointFromGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Gravity -> m ()
actorMoveAnchorPointFromGravity a
self Gravity
gravity = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let gravity' :: CUInt
gravity' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Gravity -> Int) -> Gravity -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gravity -> Int
forall a. Enum a => a -> Int
fromEnum) Gravity
gravity
    Ptr Actor -> CUInt -> IO ()
clutter_actor_move_anchor_point_from_gravity Ptr Actor
self' CUInt
gravity'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorMoveAnchorPointFromGravityMethodInfo
instance (signature ~ (Clutter.Enums.Gravity -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorMoveAnchorPointFromGravityMethodInfo a signature where
    overloadedMethod = actorMoveAnchorPointFromGravity

instance O.OverloadedMethodInfo ActorMoveAnchorPointFromGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorMoveAnchorPointFromGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorMoveAnchorPointFromGravity"
        })


#endif

-- method Actor::move_by
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dx"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Distance to move Actor on X axis."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dy"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Distance to move Actor on Y axis."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_move_by" clutter_actor_move_by :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- dx : TBasicType TFloat
    CFloat ->                               -- dy : TBasicType TFloat
    IO ()

-- | 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 'GI.Clutter.Objects.Actor.actorSetAnchorPoint', or with an additional
-- translation, using 'GI.Clutter.Objects.Actor.actorSetTranslation'.
-- 
-- /Since: 0.2/
actorMoveBy ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@dx@/: Distance to move Actor on X axis.
    -> Float
    -- ^ /@dy@/: Distance to move Actor on Y axis.
    -> m ()
actorMoveBy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> m ()
actorMoveBy a
self Float
dx Float
dy = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let dx' :: CFloat
dx' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dx
    let dy' :: CFloat
dy' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dy
    Ptr Actor -> CFloat -> CFloat -> IO ()
clutter_actor_move_by Ptr Actor
self' CFloat
dx' CFloat
dy'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorMoveByMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorMoveByMethodInfo a signature where
    overloadedMethod = actorMoveBy

instance O.OverloadedMethodInfo ActorMoveByMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorMoveBy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorMoveBy"
        })


#endif

-- method Actor::needs_expand
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "orientation"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Orientation" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the direction of expansion"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_needs_expand" clutter_actor_needs_expand :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- orientation : TInterface (Name {namespace = "Clutter", name = "Orientation"})
    IO CInt

-- | 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 'GI.Clutter.Objects.Actor.actorGetXExpand' or 'GI.Clutter.Objects.Actor.actorGetYExpand'.
-- 
-- /Since: 1.12/
actorNeedsExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.Orientation
    -- ^ /@orientation@/: the direction of expansion
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor should expand
actorNeedsExpand :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Orientation -> m Bool
actorNeedsExpand a
self Orientation
orientation = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let orientation' :: CUInt
orientation' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Orientation -> Int) -> Orientation -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Orientation -> Int
forall a. Enum a => a -> Int
fromEnum) Orientation
orientation
    CInt
result <- Ptr Actor -> CUInt -> IO CInt
clutter_actor_needs_expand Ptr Actor
self' CUInt
orientation'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorNeedsExpandMethodInfo
instance (signature ~ (Clutter.Enums.Orientation -> m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorNeedsExpandMethodInfo a signature where
    overloadedMethod = actorNeedsExpand

instance O.OverloadedMethodInfo ActorNeedsExpandMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorNeedsExpand",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorNeedsExpand"
        })


#endif

-- method Actor::paint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_paint" clutter_actor_paint :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Renders the actor to display.
-- 
-- This function should not be called directly by applications.
-- Call 'GI.Clutter.Objects.Actor.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 [Actor::paint]("GI.Clutter.Objects.Actor#g:signal:paint") signal or
-- the [Actor::pick]("GI.Clutter.Objects.Actor#g:signal: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.
actorPaint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorPaint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorPaint a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_paint Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorPaintMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorPaintMethodInfo a signature where
    overloadedMethod = actorPaint

instance O.OverloadedMethodInfo ActorPaintMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorPaint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorPaint"
        })


#endif

-- method Actor::pop_internal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_pop_internal" clutter_actor_pop_internal :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorPopInternal ["(Since version 1.10)","All children of an actor are accessible through","  the t'GI.Clutter.Objects.Actor.Actor' API. This function is only useful for legacy","  containers overriding the default implementation of the","  t'GI.Clutter.Interfaces.Container.Container' interface."] #-}
-- | Disables the effects of 'GI.Clutter.Objects.Actor.actorPushInternal'.
-- 
-- /Since: 1.2/
actorPopInternal ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorPopInternal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorPopInternal a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_pop_internal Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorPopInternalMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorPopInternalMethodInfo a signature where
    overloadedMethod = actorPopInternal

instance O.OverloadedMethodInfo ActorPopInternalMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorPopInternal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorPopInternal"
        })


#endif

-- method Actor::push_internal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_push_internal" clutter_actor_push_internal :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorPushInternal ["(Since version 1.10)","All children of an actor are accessible through","  the t'GI.Clutter.Objects.Actor.Actor' API, and t'GI.Clutter.Objects.Actor.Actor' implements the","  t'GI.Clutter.Interfaces.Container.Container' interface, so this function is only useful","  for legacy containers overriding the default implementation."] #-}
-- | Should be used by actors implementing the t'GI.Clutter.Interfaces.Container.Container' and with
-- internal children added through 'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorSetParent' is called; internal children
-- are handled differently by Clutter, specifically when destroying their
-- parent.
-- 
-- Call 'GI.Clutter.Objects.Actor.actorPopInternal' when you finished adding internal
-- children.
-- 
-- Nested calls to 'GI.Clutter.Objects.Actor.actorPushInternal' are allowed, but each
-- one must by followed by a 'GI.Clutter.Objects.Actor.actorPopInternal' call.
-- 
-- /Since: 1.2/
actorPushInternal ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorPushInternal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorPushInternal a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_push_internal Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorPushInternalMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorPushInternalMethodInfo a signature where
    overloadedMethod = actorPushInternal

instance O.OverloadedMethodInfo ActorPushInternalMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorPushInternal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorPushInternal"
        })


#endif

-- method Actor::queue_redraw
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_queue_redraw" clutter_actor_queue_redraw :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | 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.
actorQueueRedraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorQueueRedraw :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorQueueRedraw a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_queue_redraw Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorQueueRedrawMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorQueueRedrawMethodInfo a signature where
    overloadedMethod = actorQueueRedraw

instance O.OverloadedMethodInfo ActorQueueRedrawMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorQueueRedraw",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorQueueRedraw"
        })


#endif

-- method Actor::queue_redraw_with_clip
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clip"
--           , argType =
--               TInterface Name { namespace = "cairo" , name = "RectangleInt" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a rectangular clip region, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_queue_redraw_with_clip" clutter_actor_queue_redraw_with_clip :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Cairo.RectangleInt.RectangleInt ->  -- clip : TInterface (Name {namespace = "cairo", name = "RectangleInt"})
    IO ()

-- | Queues a redraw on /@self@/ limited to a specific, actor-relative
-- rectangular area.
-- 
-- If /@clip@/ is 'P.Nothing' this function is equivalent to
-- 'GI.Clutter.Objects.Actor.actorQueueRedraw'.
-- 
-- /Since: 1.10/
actorQueueRedrawWithClip ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (Cairo.RectangleInt.RectangleInt)
    -- ^ /@clip@/: a rectangular clip region, or 'P.Nothing'
    -> m ()
actorQueueRedrawWithClip :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Maybe RectangleInt -> m ()
actorQueueRedrawWithClip a
self Maybe RectangleInt
clip = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr RectangleInt
maybeClip <- case Maybe RectangleInt
clip of
        Maybe RectangleInt
Nothing -> Ptr RectangleInt -> IO (Ptr RectangleInt)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RectangleInt
forall a. Ptr a
nullPtr
        Just RectangleInt
jClip -> do
            Ptr RectangleInt
jClip' <- RectangleInt -> IO (Ptr RectangleInt)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RectangleInt
jClip
            Ptr RectangleInt -> IO (Ptr RectangleInt)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RectangleInt
jClip'
    Ptr Actor -> Ptr RectangleInt -> IO ()
clutter_actor_queue_redraw_with_clip Ptr Actor
self' Ptr RectangleInt
maybeClip
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe RectangleInt -> (RectangleInt -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RectangleInt
clip RectangleInt -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorQueueRedrawWithClipMethodInfo
instance (signature ~ (Maybe (Cairo.RectangleInt.RectangleInt) -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorQueueRedrawWithClipMethodInfo a signature where
    overloadedMethod = actorQueueRedrawWithClip

instance O.OverloadedMethodInfo ActorQueueRedrawWithClipMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorQueueRedrawWithClip",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorQueueRedrawWithClip"
        })


#endif

-- method Actor::queue_relayout
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_queue_relayout" clutter_actor_queue_relayout :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Indicates that the actor\'s size request or other layout-affecting
-- properties may have changed. This function is used inside t'GI.Clutter.Objects.Actor.Actor'
-- subclass implementations, not by applications directly.
-- 
-- Queueing a new layout automatically queues a redraw as well.
-- 
-- /Since: 0.8/
actorQueueRelayout ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorQueueRelayout :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorQueueRelayout a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_queue_relayout Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorQueueRelayoutMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorQueueRelayoutMethodInfo a signature where
    overloadedMethod = actorQueueRelayout

instance O.OverloadedMethodInfo ActorQueueRelayoutMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorQueueRelayout",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorQueueRelayout"
        })


#endif

-- method Actor::raise
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "below"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor to raise above."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_raise" clutter_actor_raise :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- below : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorRaise ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorSetChildAboveSibling' instead."] #-}
-- | Puts /@self@/ above /@below@/.
-- 
-- Both actors must have the same parent, and the parent must implement
-- the t'GI.Clutter.Interfaces.Container.Container' interface
-- 
-- This function calls 'GI.Clutter.Interfaces.Container.containerRaiseChild' internally.
actorRaise ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (b)
    -- ^ /@below@/: A t'GI.Clutter.Objects.Actor.Actor' to raise above.
    -> m ()
actorRaise :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> Maybe b -> m ()
actorRaise a
self Maybe b
below = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
maybeBelow <- case Maybe b
below of
        Maybe b
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
        Just b
jBelow -> do
            Ptr Actor
jBelow' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jBelow
            Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jBelow'
    Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_raise Ptr Actor
self' Ptr Actor
maybeBelow
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
below b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRaiseMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorRaiseMethodInfo a signature where
    overloadedMethod = actorRaise

instance O.OverloadedMethodInfo ActorRaiseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRaise",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRaise"
        })


#endif

-- method Actor::raise_top
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_raise_top" clutter_actor_raise_top :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorRaiseTop ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorSetChildAboveSibling' with","  a 'P.Nothing' sibling, instead."] #-}
-- | Raises /@self@/ to the top.
-- 
-- This function calls 'GI.Clutter.Objects.Actor.actorRaise' internally.
actorRaiseTop ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorRaiseTop :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorRaiseTop a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_raise_top Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRaiseTopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRaiseTopMethodInfo a signature where
    overloadedMethod = actorRaiseTop

instance O.OverloadedMethodInfo ActorRaiseTopMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRaiseTop",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRaiseTop"
        })


#endif

-- method Actor::realize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_realize" clutter_actor_realize :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorRealize ["(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
-- 'GI.Clutter.Objects.Actor.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.
actorRealize ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorRealize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorRealize a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_realize Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRealizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRealizeMethodInfo a signature where
    overloadedMethod = actorRealize

instance O.OverloadedMethodInfo ActorRealizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRealize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRealize"
        })


#endif

-- method Actor::remove_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Action" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterAction" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_action" clutter_actor_remove_action :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Action.Action ->            -- action : TInterface (Name {namespace = "Clutter", name = "Action"})
    IO ()

-- | Removes /@action@/ from the list of actions applied to /@self@/
-- 
-- The reference held by /@self@/ on the t'GI.Clutter.Objects.Action.Action' will be released
-- 
-- /Since: 1.4/
actorRemoveAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Action.IsAction b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@action@/: a t'GI.Clutter.Objects.Action.Action'
    -> m ()
actorRemoveAction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsAction b) =>
a -> b -> m ()
actorRemoveAction a
self b
action = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Action
action' <- b -> IO (Ptr Action)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
action
    Ptr Actor -> Ptr Action -> IO ()
clutter_actor_remove_action Ptr Actor
self' Ptr Action
action'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
action
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveActionMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, Clutter.Action.IsAction b) => O.OverloadedMethod ActorRemoveActionMethodInfo a signature where
    overloadedMethod = actorRemoveAction

instance O.OverloadedMethodInfo ActorRemoveActionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveAction"
        })


#endif

-- method Actor::remove_action_by_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the action to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_action_by_name" clutter_actor_remove_action_by_name :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Removes the t'GI.Clutter.Objects.Action.Action' with the given name from the list
-- of actions applied to /@self@/
-- 
-- /Since: 1.4/
actorRemoveActionByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the action to remove
    -> m ()
actorRemoveActionByName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m ()
actorRemoveActionByName a
self Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Actor -> CString -> IO ()
clutter_actor_remove_action_by_name Ptr Actor
self' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveActionByNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRemoveActionByNameMethodInfo a signature where
    overloadedMethod = actorRemoveActionByName

instance O.OverloadedMethodInfo ActorRemoveActionByNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveActionByName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveActionByName"
        })


#endif

-- method Actor::remove_all_children
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_all_children" clutter_actor_remove_all_children :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | 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 'GI.Clutter.Objects.Actor.actorDestroyAllChildren'.
-- 
-- /Since: 1.10/
actorRemoveAllChildren ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorRemoveAllChildren :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorRemoveAllChildren a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_remove_all_children Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveAllChildrenMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRemoveAllChildrenMethodInfo a signature where
    overloadedMethod = actorRemoveAllChildren

instance O.OverloadedMethodInfo ActorRemoveAllChildrenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveAllChildren",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveAllChildren"
        })


#endif

-- method Actor::remove_all_transitions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_all_transitions" clutter_actor_remove_all_transitions :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Removes all transitions associated to /@self@/.
-- 
-- /Since: 1.10/
actorRemoveAllTransitions ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorRemoveAllTransitions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorRemoveAllTransitions a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_remove_all_transitions Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveAllTransitionsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRemoveAllTransitionsMethodInfo a signature where
    overloadedMethod = actorRemoveAllTransitions

instance O.OverloadedMethodInfo ActorRemoveAllTransitionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveAllTransitions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveAllTransitions"
        })


#endif

-- method Actor::remove_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_child" clutter_actor_remove_child :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Removes /@child@/ from the children of /@self@/.
-- 
-- This function will release the reference added by
-- 'GI.Clutter.Objects.Actor.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 [Container::actorRemoved]("GI.Clutter.Interfaces.Container#g:signal:actorRemoved")
-- signal on /@self@/.
-- 
-- /Since: 1.10/
actorRemoveChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@child@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorRemoveChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> b -> m ()
actorRemoveChild a
self b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
child' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_remove_child Ptr Actor
self' Ptr Actor
child'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveChildMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorRemoveChildMethodInfo a signature where
    overloadedMethod = actorRemoveChild

instance O.OverloadedMethodInfo ActorRemoveChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveChild"
        })


#endif

-- method Actor::remove_clip
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_clip" clutter_actor_remove_clip :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Removes clip area from /@self@/.
actorRemoveClip ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorRemoveClip :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorRemoveClip a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_remove_clip Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveClipMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRemoveClipMethodInfo a signature where
    overloadedMethod = actorRemoveClip

instance O.OverloadedMethodInfo ActorRemoveClipMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveClip",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveClip"
        })


#endif

-- method Actor::remove_constraint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "constraint"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Constraint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterConstraint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_constraint" clutter_actor_remove_constraint :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Constraint.Constraint ->    -- constraint : TInterface (Name {namespace = "Clutter", name = "Constraint"})
    IO ()

-- | Removes /@constraint@/ from the list of constraints applied to /@self@/
-- 
-- The reference held by /@self@/ on the t'GI.Clutter.Objects.Constraint.Constraint' will be released
-- 
-- /Since: 1.4/
actorRemoveConstraint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Constraint.IsConstraint b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@constraint@/: a t'GI.Clutter.Objects.Constraint.Constraint'
    -> m ()
actorRemoveConstraint :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsConstraint b) =>
a -> b -> m ()
actorRemoveConstraint a
self b
constraint = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Constraint
constraint' <- b -> IO (Ptr Constraint)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
constraint
    Ptr Actor -> Ptr Constraint -> IO ()
clutter_actor_remove_constraint Ptr Actor
self' Ptr Constraint
constraint'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
constraint
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveConstraintMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, Clutter.Constraint.IsConstraint b) => O.OverloadedMethod ActorRemoveConstraintMethodInfo a signature where
    overloadedMethod = actorRemoveConstraint

instance O.OverloadedMethodInfo ActorRemoveConstraintMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveConstraint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveConstraint"
        })


#endif

-- method Actor::remove_constraint_by_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the constraint to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_constraint_by_name" clutter_actor_remove_constraint_by_name :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Removes the t'GI.Clutter.Objects.Constraint.Constraint' with the given name from the list
-- of constraints applied to /@self@/
-- 
-- /Since: 1.4/
actorRemoveConstraintByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the constraint to remove
    -> m ()
actorRemoveConstraintByName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m ()
actorRemoveConstraintByName a
self Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Actor -> CString -> IO ()
clutter_actor_remove_constraint_by_name Ptr Actor
self' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveConstraintByNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRemoveConstraintByNameMethodInfo a signature where
    overloadedMethod = actorRemoveConstraintByName

instance O.OverloadedMethodInfo ActorRemoveConstraintByNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveConstraintByName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveConstraintByName"
        })


#endif

-- method Actor::remove_effect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Effect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEffect" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_effect" clutter_actor_remove_effect :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Effect.Effect ->            -- effect : TInterface (Name {namespace = "Clutter", name = "Effect"})
    IO ()

-- | Removes /@effect@/ from the list of effects applied to /@self@/
-- 
-- The reference held by /@self@/ on the t'GI.Clutter.Objects.Effect.Effect' will be released
-- 
-- /Since: 1.4/
actorRemoveEffect ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Effect.IsEffect b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@effect@/: a t'GI.Clutter.Objects.Effect.Effect'
    -> m ()
actorRemoveEffect :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsEffect b) =>
a -> b -> m ()
actorRemoveEffect a
self b
effect = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Effect
effect' <- b -> IO (Ptr Effect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    Ptr Actor -> Ptr Effect -> IO ()
clutter_actor_remove_effect Ptr Actor
self' Ptr Effect
effect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveEffectMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, Clutter.Effect.IsEffect b) => O.OverloadedMethod ActorRemoveEffectMethodInfo a signature where
    overloadedMethod = actorRemoveEffect

instance O.OverloadedMethodInfo ActorRemoveEffectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveEffect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveEffect"
        })


#endif

-- method Actor::remove_effect_by_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the effect to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_effect_by_name" clutter_actor_remove_effect_by_name :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Removes the t'GI.Clutter.Objects.Effect.Effect' with the given name from the list
-- of effects applied to /@self@/
-- 
-- /Since: 1.4/
actorRemoveEffectByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the effect to remove
    -> m ()
actorRemoveEffectByName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m ()
actorRemoveEffectByName a
self Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Actor -> CString -> IO ()
clutter_actor_remove_effect_by_name Ptr Actor
self' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveEffectByNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRemoveEffectByNameMethodInfo a signature where
    overloadedMethod = actorRemoveEffectByName

instance O.OverloadedMethodInfo ActorRemoveEffectByNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveEffectByName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveEffectByName"
        })


#endif

-- method Actor::remove_transition
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the transition to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_remove_transition" clutter_actor_remove_transition :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Removes the transition stored inside a t'GI.Clutter.Objects.Actor.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 t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
actorRemoveTransition ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: the name of the transition to remove
    -> m ()
actorRemoveTransition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m ()
actorRemoveTransition a
self Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Actor -> CString -> IO ()
clutter_actor_remove_transition Ptr Actor
self' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRemoveTransitionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRemoveTransitionMethodInfo a signature where
    overloadedMethod = actorRemoveTransition

instance O.OverloadedMethodInfo ActorRemoveTransitionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRemoveTransition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRemoveTransition"
        })


#endif

-- method Actor::reparent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "new_parent"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new #ClutterActor parent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_reparent" clutter_actor_reparent :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- new_parent : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorReparent ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorRemoveChild' and","  'GI.Clutter.Objects.Actor.actorAddChild' instead; remember to take a reference on","  the actor being removed before calling 'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorUnparent'
-- and 'GI.Clutter.Objects.Actor.actorSetParent', but more efficiently implemented, as it
-- ensures the child is not finalized when unparented, and emits the
-- [Actor::parentSet]("GI.Clutter.Objects.Actor#g:signal: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/
actorReparent ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@newParent@/: the new t'GI.Clutter.Objects.Actor.Actor' parent
    -> m ()
actorReparent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> b -> m ()
actorReparent a
self b
newParent = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
newParent' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
newParent
    Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_reparent Ptr Actor
self' Ptr Actor
newParent'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
newParent
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorReparentMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorReparentMethodInfo a signature where
    overloadedMethod = actorReparent

instance O.OverloadedMethodInfo ActorReparentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorReparent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorReparent"
        })


#endif

-- method Actor::replace_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "old_child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child of @self to replace"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "new_child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterActor to replace @old_child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_replace_child" clutter_actor_replace_child :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- old_child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- new_child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Replaces /@oldChild@/ with /@newChild@/ in the list of children of /@self@/.
-- 
-- /Since: 1.10/
actorReplaceChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@oldChild@/: the child of /@self@/ to replace
    -> c
    -- ^ /@newChild@/: the t'GI.Clutter.Objects.Actor.Actor' to replace /@oldChild@/
    -> m ()
actorReplaceChild :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
a -> b -> c -> m ()
actorReplaceChild a
self b
oldChild c
newChild = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
oldChild' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
oldChild
    Ptr Actor
newChild' <- c -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
newChild
    Ptr Actor -> Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_replace_child Ptr Actor
self' Ptr Actor
oldChild' Ptr Actor
newChild'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
oldChild
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
newChild
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorReplaceChildMethodInfo
instance (signature ~ (b -> c -> m ()), MonadIO m, IsActor a, IsActor b, IsActor c) => O.OverloadedMethod ActorReplaceChildMethodInfo a signature where
    overloadedMethod = actorReplaceChild

instance O.OverloadedMethodInfo ActorReplaceChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorReplaceChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorReplaceChild"
        })


#endif

-- method Actor::restore_easing_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_restore_easing_state" clutter_actor_restore_easing_state :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Restores the easing state as it was prior to a call to
-- 'GI.Clutter.Objects.Actor.actorSaveEasingState'.
-- 
-- /Since: 1.10/
actorRestoreEasingState ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorRestoreEasingState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorRestoreEasingState a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_restore_easing_state Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorRestoreEasingStateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorRestoreEasingStateMethodInfo a signature where
    overloadedMethod = actorRestoreEasingState

instance O.OverloadedMethodInfo ActorRestoreEasingStateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorRestoreEasingState",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorRestoreEasingState"
        })


#endif

-- method Actor::save_easing_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_save_easing_state" clutter_actor_save_easing_state :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | 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/
actorSaveEasingState ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorSaveEasingState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorSaveEasingState a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_save_easing_state Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSaveEasingStateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSaveEasingStateMethodInfo a signature where
    overloadedMethod = actorSaveEasingState

instance O.OverloadedMethodInfo ActorSaveEasingStateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSaveEasingState",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSaveEasingState"
        })


#endif

-- method Actor::set_allocation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "box"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorBox" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActorBox" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "AllocationFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "allocation flags" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_allocation" clutter_actor_set_allocation :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.ActorBox.ActorBox ->        -- box : TInterface (Name {namespace = "Clutter", name = "ActorBox"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "AllocationFlags"})
    IO ()

-- | Stores the allocation of /@self@/ as defined by /@box@/.
-- 
-- This function can only be called from within the implementation of
-- the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/allocate/@() virtual function.
-- 
-- The allocation should have been adjusted to take into account constraints,
-- alignment, and margin properties. If you are implementing a t'GI.Clutter.Objects.Actor.Actor'
-- subclass that provides its own layout management policy for its children
-- instead of using a t'GI.Clutter.Objects.LayoutManager.LayoutManager' delegate, you should not call
-- this function on the children of /@self@/; instead, you should call
-- 'GI.Clutter.Objects.Actor.actorAllocate', which will adjust the allocation box for
-- you.
-- 
-- This function should only be used by subclasses of t'GI.Clutter.Objects.Actor.Actor'
-- that wish to store their allocation but cannot chain up to the
-- parent\'s implementation; the default implementation of the
-- t'GI.Clutter.Structs.ActorClass.ActorClass'.@/allocate/@() virtual function will call this
-- function.
-- 
-- It is important to note that, while chaining up was the recommended
-- behaviour for t'GI.Clutter.Objects.Actor.Actor' subclasses prior to the introduction of
-- this function, it is recommended to call 'GI.Clutter.Objects.Actor.actorSetAllocation'
-- instead.
-- 
-- If the t'GI.Clutter.Objects.Actor.Actor' is using a t'GI.Clutter.Objects.LayoutManager.LayoutManager' delegate object
-- to handle the allocation of its children, this function will call
-- the 'GI.Clutter.Objects.LayoutManager.layoutManagerAllocate' function only if the
-- 'GI.Clutter.Flags.AllocationFlagsDelegateLayout' flag is set on /@flags@/, otherwise it is
-- expected that the subclass will call 'GI.Clutter.Objects.LayoutManager.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/
actorSetAllocation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.ActorBox.ActorBox
    -- ^ /@box@/: a t'GI.Clutter.Structs.ActorBox.ActorBox'
    -> [Clutter.Flags.AllocationFlags]
    -- ^ /@flags@/: allocation flags
    -> m ()
actorSetAllocation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> ActorBox -> [AllocationFlags] -> m ()
actorSetAllocation a
self ActorBox
box [AllocationFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActorBox
box' <- ActorBox -> IO (Ptr ActorBox)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ActorBox
box
    let flags' :: CUInt
flags' = [AllocationFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [AllocationFlags]
flags
    Ptr Actor -> Ptr ActorBox -> CUInt -> IO ()
clutter_actor_set_allocation Ptr Actor
self' Ptr ActorBox
box' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ActorBox -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ActorBox
box
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetAllocationMethodInfo
instance (signature ~ (Clutter.ActorBox.ActorBox -> [Clutter.Flags.AllocationFlags] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetAllocationMethodInfo a signature where
    overloadedMethod = actorSetAllocation

instance O.OverloadedMethodInfo ActorSetAllocationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetAllocation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetAllocation"
        })


#endif

-- method Actor::set_anchor_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "anchor_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "X coordinate of the anchor point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "anchor_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Y coordinate of the anchor point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_anchor_point" clutter_actor_set_anchor_point :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- anchor_x : TBasicType TFloat
    CFloat ->                               -- anchor_y : TBasicType TFloat
    IO ()

{-# DEPRECATED actorSetAnchorPoint ["(Since version 1.12)","Use [Actor:pivotPoint](\"GI.Clutter.Objects.Actor#g:attr:pivotPoint\") 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/
actorSetAnchorPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@anchorX@/: X coordinate of the anchor point
    -> Float
    -- ^ /@anchorY@/: Y coordinate of the anchor point
    -> m ()
actorSetAnchorPoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> m ()
actorSetAnchorPoint a
self Float
anchorX Float
anchorY = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let anchorX' :: CFloat
anchorX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
anchorX
    let anchorY' :: CFloat
anchorY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
anchorY
    Ptr Actor -> CFloat -> CFloat -> IO ()
clutter_actor_set_anchor_point Ptr Actor
self' CFloat
anchorX' CFloat
anchorY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetAnchorPointMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetAnchorPointMethodInfo a signature where
    overloadedMethod = actorSetAnchorPoint

instance O.OverloadedMethodInfo ActorSetAnchorPointMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetAnchorPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetAnchorPoint"
        })


#endif

-- method Actor::set_anchor_point_from_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gravity"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Gravity" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#ClutterGravity." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_anchor_point_from_gravity" clutter_actor_set_anchor_point_from_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- gravity : TInterface (Name {namespace = "Clutter", name = "Gravity"})
    IO ()

{-# DEPRECATED actorSetAnchorPointFromGravity ["(Since version 1.12)","Use [Actor:pivotPoint](\"GI.Clutter.Objects.Actor#g:attr:pivotPoint\") and","'GI.Clutter.Objects.Actor.actorSetTranslation' instead. E.g. For 'GI.Clutter.Enums.GravityCenter' set","pivot_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 'GI.Clutter.Objects.Actor.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 'GI.Clutter.Enums.GravitySouthEast'
-- and later double the size of the actor, the anchor point will move
-- to the bottom right.
-- 
-- /Since: 0.6/
actorSetAnchorPointFromGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.Gravity
    -- ^ /@gravity@/: t'GI.Clutter.Enums.Gravity'.
    -> m ()
actorSetAnchorPointFromGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Gravity -> m ()
actorSetAnchorPointFromGravity a
self Gravity
gravity = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let gravity' :: CUInt
gravity' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Gravity -> Int) -> Gravity -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gravity -> Int
forall a. Enum a => a -> Int
fromEnum) Gravity
gravity
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_anchor_point_from_gravity Ptr Actor
self' CUInt
gravity'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetAnchorPointFromGravityMethodInfo
instance (signature ~ (Clutter.Enums.Gravity -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetAnchorPointFromGravityMethodInfo a signature where
    overloadedMethod = actorSetAnchorPointFromGravity

instance O.OverloadedMethodInfo ActorSetAnchorPointFromGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetAnchorPointFromGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetAnchorPointFromGravity"
        })


#endif

-- method Actor::set_background_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #ClutterColor, or %NULL to unset a previously\n set color"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_background_color" clutter_actor_set_background_color :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO ()

-- | Sets the background color of a t'GI.Clutter.Objects.Actor.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:backgroundColorSet]("GI.Clutter.Objects.Actor#g:attr:backgroundColorSet") actor property.
-- 
-- The [Actor:backgroundColor]("GI.Clutter.Objects.Actor#g:attr:backgroundColor") property is animatable.
-- 
-- /Since: 1.10/
actorSetBackgroundColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (Clutter.Color.Color)
    -- ^ /@color@/: a t'GI.Clutter.Structs.Color.Color', or 'P.Nothing' to unset a previously
    --  set color
    -> m ()
actorSetBackgroundColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Maybe Color -> m ()
actorSetBackgroundColor a
self Maybe Color
color = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
maybeColor <- case Maybe Color
color of
        Maybe Color
Nothing -> Ptr Color -> IO (Ptr Color)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Color
forall a. Ptr a
nullPtr
        Just Color
jColor -> do
            Ptr Color
jColor' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
jColor
            Ptr Color -> IO (Ptr Color)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Color
jColor'
    Ptr Actor -> Ptr Color -> IO ()
clutter_actor_set_background_color Ptr Actor
self' Ptr Color
maybeColor
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Color -> ActorPickCallback -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Color
color ActorPickCallback
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetBackgroundColorMethodInfo
instance (signature ~ (Maybe (Clutter.Color.Color) -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetBackgroundColorMethodInfo a signature where
    overloadedMethod = actorSetBackgroundColor

instance O.OverloadedMethodInfo ActorSetBackgroundColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetBackgroundColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetBackgroundColor"
        })


#endif

-- method Actor::set_child_above_sibling
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor child of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sibling"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor child of @self, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_child_above_sibling" clutter_actor_set_child_above_sibling :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- sibling : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Sets /@child@/ to be above /@sibling@/ in the list of children of /@self@/.
-- 
-- If /@sibling@/ is 'P.Nothing', /@child@/ will be the new last child of /@self@/.
-- 
-- This function is logically equivalent to removing /@child@/ and using
-- 'GI.Clutter.Objects.Actor.actorInsertChildAbove', but it will not emit signals
-- or change state on /@child@/.
-- 
-- /Since: 1.10/
actorSetChildAboveSibling ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@child@/: a t'GI.Clutter.Objects.Actor.Actor' child of /@self@/
    -> Maybe (c)
    -- ^ /@sibling@/: a t'GI.Clutter.Objects.Actor.Actor' child of /@self@/, or 'P.Nothing'
    -> m ()
actorSetChildAboveSibling :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
a -> b -> Maybe c -> m ()
actorSetChildAboveSibling a
self b
child Maybe c
sibling = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
child' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Actor
maybeSibling <- case Maybe c
sibling of
        Maybe c
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
        Just c
jSibling -> do
            Ptr Actor
jSibling' <- c -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSibling
            Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jSibling'
    Ptr Actor -> Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_set_child_above_sibling Ptr Actor
self' Ptr Actor
child' Ptr Actor
maybeSibling
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetChildAboveSiblingMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsActor a, IsActor b, IsActor c) => O.OverloadedMethod ActorSetChildAboveSiblingMethodInfo a signature where
    overloadedMethod = actorSetChildAboveSibling

instance O.OverloadedMethodInfo ActorSetChildAboveSiblingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetChildAboveSibling",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetChildAboveSibling"
        })


#endif

-- method Actor::set_child_at_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor child of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new index for @child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_child_at_index" clutter_actor_set_child_at_index :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Int32 ->                                -- index_ : TBasicType TInt
    IO ()

-- | Changes the index of /@child@/ in the list of children of /@self@/.
-- 
-- This function is logically equivalent to removing /@child@/ and
-- calling 'GI.Clutter.Objects.Actor.actorInsertChildAtIndex', but it will not
-- emit signals or change state on /@child@/.
-- 
-- /Since: 1.10/
actorSetChildAtIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@child@/: a t'GI.Clutter.Objects.Actor.Actor' child of /@self@/
    -> Int32
    -- ^ /@index_@/: the new index for /@child@/
    -> m ()
actorSetChildAtIndex :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> b -> Int32 -> m ()
actorSetChildAtIndex a
self b
child Int32
index_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
child' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Actor -> Ptr Actor -> Int32 -> IO ()
clutter_actor_set_child_at_index Ptr Actor
self' Ptr Actor
child' Int32
index_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetChildAtIndexMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorSetChildAtIndexMethodInfo a signature where
    overloadedMethod = actorSetChildAtIndex

instance O.OverloadedMethodInfo ActorSetChildAtIndexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetChildAtIndex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetChildAtIndex"
        })


#endif

-- method Actor::set_child_below_sibling
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor child of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sibling"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor child of @self, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_child_below_sibling" clutter_actor_set_child_below_sibling :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- child : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- sibling : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Sets /@child@/ to be below /@sibling@/ in the list of children of /@self@/.
-- 
-- If /@sibling@/ is 'P.Nothing', /@child@/ will be the new first child of /@self@/.
-- 
-- This function is logically equivalent to removing /@self@/ and using
-- 'GI.Clutter.Objects.Actor.actorInsertChildBelow', but it will not emit signals
-- or change state on /@child@/.
-- 
-- /Since: 1.10/
actorSetChildBelowSibling ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@child@/: a t'GI.Clutter.Objects.Actor.Actor' child of /@self@/
    -> Maybe (c)
    -- ^ /@sibling@/: a t'GI.Clutter.Objects.Actor.Actor' child of /@self@/, or 'P.Nothing'
    -> m ()
actorSetChildBelowSibling :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsActor a, IsActor b, IsActor c) =>
a -> b -> Maybe c -> m ()
actorSetChildBelowSibling a
self b
child Maybe c
sibling = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
child' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Actor
maybeSibling <- case Maybe c
sibling of
        Maybe c
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
        Just c
jSibling -> do
            Ptr Actor
jSibling' <- c -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jSibling
            Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jSibling'
    Ptr Actor -> Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_set_child_below_sibling Ptr Actor
self' Ptr Actor
child' Ptr Actor
maybeSibling
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
sibling c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetChildBelowSiblingMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsActor a, IsActor b, IsActor c) => O.OverloadedMethod ActorSetChildBelowSiblingMethodInfo a signature where
    overloadedMethod = actorSetChildBelowSibling

instance O.OverloadedMethodInfo ActorSetChildBelowSiblingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetChildBelowSibling",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetChildBelowSibling"
        })


#endif

-- method Actor::set_child_transform
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "transform"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Matrix" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterMatrix, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_child_transform" clutter_actor_set_child_transform :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Matrix.Matrix ->            -- transform : TInterface (Name {namespace = "Clutter", name = "Matrix"})
    IO ()

-- | 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 'P.Nothing', the child transform will be unset.
-- 
-- The [Actor:childTransform]("GI.Clutter.Objects.Actor#g:attr:childTransform") property is animatable.
-- 
-- /Since: 1.12/
actorSetChildTransform ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (Clutter.Matrix.Matrix)
    -- ^ /@transform@/: a t'GI.Clutter.Structs.Matrix.Matrix', or 'P.Nothing'
    -> m ()
actorSetChildTransform :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Maybe Matrix -> m ()
actorSetChildTransform a
self Maybe Matrix
transform = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Matrix
maybeTransform <- case Maybe Matrix
transform of
        Maybe Matrix
Nothing -> Ptr Matrix -> IO (Ptr Matrix)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Matrix
forall a. Ptr a
nullPtr
        Just Matrix
jTransform -> do
            Ptr Matrix
jTransform' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
jTransform
            Ptr Matrix -> IO (Ptr Matrix)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Matrix
jTransform'
    Ptr Actor -> Ptr Matrix -> IO ()
clutter_actor_set_child_transform Ptr Actor
self' Ptr Matrix
maybeTransform
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Matrix -> (Matrix -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Matrix
transform Matrix -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetChildTransformMethodInfo
instance (signature ~ (Maybe (Clutter.Matrix.Matrix) -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetChildTransformMethodInfo a signature where
    overloadedMethod = actorSetChildTransform

instance O.OverloadedMethodInfo ActorSetChildTransformMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetChildTransform",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetChildTransform"
        })


#endif

-- method Actor::set_clip
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xoff"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "X offset of the clip rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "yoff"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Y offset of the clip rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Width of the clip rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Height of the clip rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_clip" clutter_actor_set_clip :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- xoff : TBasicType TFloat
    CFloat ->                               -- yoff : TBasicType TFloat
    CFloat ->                               -- width : TBasicType TFloat
    CFloat ->                               -- height : TBasicType TFloat
    IO ()

-- | 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/
actorSetClip ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.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 ()
actorSetClip :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> Float -> Float -> m ()
actorSetClip a
self Float
xoff Float
yoff Float
width Float
height = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let xoff' :: CFloat
xoff' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xoff
    let yoff' :: CFloat
yoff' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
yoff
    let width' :: CFloat
width' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
width
    let height' :: CFloat
height' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
height
    Ptr Actor -> CFloat -> CFloat -> CFloat -> CFloat -> IO ()
clutter_actor_set_clip Ptr Actor
self' CFloat
xoff' CFloat
yoff' CFloat
width' CFloat
height'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetClipMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetClipMethodInfo a signature where
    overloadedMethod = actorSetClip

instance O.OverloadedMethodInfo ActorSetClipMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetClip",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetClip"
        })


#endif

-- method Actor::set_clip_to_allocation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clip_set"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to apply a clip tracking the allocation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_clip_to_allocation" clutter_actor_set_clip_to_allocation :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CInt ->                                 -- clip_set : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ should be clipped to the same size as its
-- allocation
-- 
-- /Since: 1.4/
actorSetClipToAllocation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Bool
    -- ^ /@clipSet@/: 'P.True' to apply a clip tracking the allocation
    -> m ()
actorSetClipToAllocation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Bool -> m ()
actorSetClipToAllocation a
self Bool
clipSet = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let clipSet' :: CInt
clipSet' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
clipSet
    Ptr Actor -> CInt -> IO ()
clutter_actor_set_clip_to_allocation Ptr Actor
self' CInt
clipSet'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetClipToAllocationMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetClipToAllocationMethodInfo a signature where
    overloadedMethod = actorSetClipToAllocation

instance O.OverloadedMethodInfo ActorSetClipToAllocationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetClipToAllocation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetClipToAllocation"
        })


#endif

-- method Actor::set_content
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Content" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterContent, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_content" clutter_actor_set_content :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Content.Content ->          -- content : TInterface (Name {namespace = "Clutter", name = "Content"})
    IO ()

-- | Sets the contents of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
actorSetContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Content.IsContent b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (b)
    -- ^ /@content@/: a t'GI.Clutter.Interfaces.Content.Content', or 'P.Nothing'
    -> m ()
actorSetContent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsContent b) =>
a -> Maybe b -> m ()
actorSetContent a
self Maybe b
content = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Content
maybeContent <- case Maybe b
content of
        Maybe b
Nothing -> Ptr Content -> IO (Ptr Content)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Content
forall a. Ptr a
nullPtr
        Just b
jContent -> do
            Ptr Content
jContent' <- b -> IO (Ptr Content)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jContent
            Ptr Content -> IO (Ptr Content)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Content
jContent'
    Ptr Actor -> Ptr Content -> IO ()
clutter_actor_set_content Ptr Actor
self' Ptr Content
maybeContent
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
content b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetContentMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActor a, Clutter.Content.IsContent b) => O.OverloadedMethod ActorSetContentMethodInfo a signature where
    overloadedMethod = actorSetContent

instance O.OverloadedMethodInfo ActorSetContentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetContent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetContent"
        })


#endif

-- method Actor::set_content_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gravity"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ContentGravity" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterContentGravity"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_content_gravity" clutter_actor_set_content_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- gravity : TInterface (Name {namespace = "Clutter", name = "ContentGravity"})
    IO ()

-- | Sets the gravity of the t'GI.Clutter.Interfaces.Content.Content' used by /@self@/.
-- 
-- See the description of the [Actor:contentGravity]("GI.Clutter.Objects.Actor#g:attr:contentGravity") property for
-- more information.
-- 
-- The [Actor:contentGravity]("GI.Clutter.Objects.Actor#g:attr:contentGravity") property is animatable.
-- 
-- /Since: 1.10/
actorSetContentGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.ContentGravity
    -- ^ /@gravity@/: the t'GI.Clutter.Enums.ContentGravity'
    -> m ()
actorSetContentGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> ContentGravity -> m ()
actorSetContentGravity a
self ContentGravity
gravity = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let gravity' :: CUInt
gravity' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (ContentGravity -> Int) -> ContentGravity -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContentGravity -> Int
forall a. Enum a => a -> Int
fromEnum) ContentGravity
gravity
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_content_gravity Ptr Actor
self' CUInt
gravity'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetContentGravityMethodInfo
instance (signature ~ (Clutter.Enums.ContentGravity -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetContentGravityMethodInfo a signature where
    overloadedMethod = actorSetContentGravity

instance O.OverloadedMethodInfo ActorSetContentGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetContentGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetContentGravity"
        })


#endif

-- method Actor::set_content_repeat
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "repeat"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ContentRepeat" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the repeat policy" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_content_repeat" clutter_actor_set_content_repeat :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- repeat : TInterface (Name {namespace = "Clutter", name = "ContentRepeat"})
    IO ()

-- | Sets the policy for repeating the [Actor:content]("GI.Clutter.Objects.Actor#g:attr:content") of a
-- t'GI.Clutter.Objects.Actor.Actor'. The behaviour is deferred to the t'GI.Clutter.Interfaces.Content.Content'
-- implementation.
-- 
-- /Since: 1.12/
actorSetContentRepeat ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> [Clutter.Flags.ContentRepeat]
    -- ^ /@repeat@/: the repeat policy
    -> m ()
actorSetContentRepeat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> [ContentRepeat] -> m ()
actorSetContentRepeat a
self [ContentRepeat]
repeat = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let repeat' :: CUInt
repeat' = [ContentRepeat] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ContentRepeat]
repeat
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_content_repeat Ptr Actor
self' CUInt
repeat'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetContentRepeatMethodInfo
instance (signature ~ ([Clutter.Flags.ContentRepeat] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetContentRepeatMethodInfo a signature where
    overloadedMethod = actorSetContentRepeat

instance O.OverloadedMethodInfo ActorSetContentRepeatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetContentRepeat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetContentRepeat"
        })


#endif

-- method Actor::set_content_scaling_filters
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_filter"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ScalingFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the minification filter for the content"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mag_filter"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ScalingFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the magnification filter for the content"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_content_scaling_filters" clutter_actor_set_content_scaling_filters :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- min_filter : TInterface (Name {namespace = "Clutter", name = "ScalingFilter"})
    CUInt ->                                -- mag_filter : TInterface (Name {namespace = "Clutter", name = "ScalingFilter"})
    IO ()

-- | Sets the minification and magnification filter to be applied when
-- scaling the [Actor:content]("GI.Clutter.Objects.Actor#g:attr:content") of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- The [Actor:minificationFilter]("GI.Clutter.Objects.Actor#g:attr:minificationFilter") will be used when reducing
-- the size of the content; the [Actor:magnificationFilter]("GI.Clutter.Objects.Actor#g:attr:magnificationFilter")
-- will be used when increasing the size of the content.
-- 
-- /Since: 1.10/
actorSetContentScalingFilters ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.ScalingFilter
    -- ^ /@minFilter@/: the minification filter for the content
    -> Clutter.Enums.ScalingFilter
    -- ^ /@magFilter@/: the magnification filter for the content
    -> m ()
actorSetContentScalingFilters :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> ScalingFilter -> ScalingFilter -> m ()
actorSetContentScalingFilters a
self ScalingFilter
minFilter ScalingFilter
magFilter = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let minFilter' :: CUInt
minFilter' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ScalingFilter -> Int) -> ScalingFilter -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScalingFilter -> Int
forall a. Enum a => a -> Int
fromEnum) ScalingFilter
minFilter
    let magFilter' :: CUInt
magFilter' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ScalingFilter -> Int) -> ScalingFilter -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScalingFilter -> Int
forall a. Enum a => a -> Int
fromEnum) ScalingFilter
magFilter
    Ptr Actor -> CUInt -> CUInt -> IO ()
clutter_actor_set_content_scaling_filters Ptr Actor
self' CUInt
minFilter' CUInt
magFilter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetContentScalingFiltersMethodInfo
instance (signature ~ (Clutter.Enums.ScalingFilter -> Clutter.Enums.ScalingFilter -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetContentScalingFiltersMethodInfo a signature where
    overloadedMethod = actorSetContentScalingFilters

instance O.OverloadedMethodInfo ActorSetContentScalingFiltersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetContentScalingFilters",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetContentScalingFilters"
        })


#endif

-- method Actor::set_depth
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "depth"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Z co-ord" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_depth" clutter_actor_set_depth :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- depth : TBasicType TFloat
    IO ()

{-# DEPRECATED actorSetDepth ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.actorSetZPosition' instead."] #-}
-- | Sets the Z coordinate of /@self@/ to /@depth@/.
-- 
-- The unit used by /@depth@/ is dependant on the perspective setup. See
-- also 'GI.Clutter.Objects.Stage.stageSetPerspective'.
actorSetDepth ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@depth@/: Z co-ord
    -> m ()
actorSetDepth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetDepth a
self Float
depth = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let depth' :: CFloat
depth' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
depth
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_depth Ptr Actor
self' CFloat
depth'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetDepthMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetDepthMethodInfo a signature where
    overloadedMethod = actorSetDepth

instance O.OverloadedMethodInfo ActorSetDepthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetDepth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetDepth"
        })


#endif

-- method Actor::set_easing_delay
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msecs"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the delay before the start of the tweening, in milliseconds"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_easing_delay" clutter_actor_set_easing_delay :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Word32 ->                               -- msecs : TBasicType TUInt
    IO ()

-- | Sets the delay that should be applied before tweening animatable
-- properties.
-- 
-- /Since: 1.10/
actorSetEasingDelay ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Word32
    -- ^ /@msecs@/: the delay before the start of the tweening, in milliseconds
    -> m ()
actorSetEasingDelay :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Word32 -> m ()
actorSetEasingDelay a
self Word32
msecs = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> Word32 -> IO ()
clutter_actor_set_easing_delay Ptr Actor
self' Word32
msecs
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetEasingDelayMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetEasingDelayMethodInfo a signature where
    overloadedMethod = actorSetEasingDelay

instance O.OverloadedMethodInfo ActorSetEasingDelayMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetEasingDelay",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetEasingDelay"
        })


#endif

-- method Actor::set_easing_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msecs"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the duration of the easing, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_easing_duration" clutter_actor_set_easing_duration :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Word32 ->                               -- msecs : TBasicType TUInt
    IO ()

-- | Sets the duration of the tweening for animatable properties
-- of /@self@/ for the current easing state.
-- 
-- /Since: 1.10/
actorSetEasingDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Word32
    -- ^ /@msecs@/: the duration of the easing, or 'P.Nothing'
    -> m ()
actorSetEasingDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Word32 -> m ()
actorSetEasingDuration a
self Word32
msecs = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> Word32 -> IO ()
clutter_actor_set_easing_duration Ptr Actor
self' Word32
msecs
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetEasingDurationMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetEasingDurationMethodInfo a signature where
    overloadedMethod = actorSetEasingDuration

instance O.OverloadedMethodInfo ActorSetEasingDurationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetEasingDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetEasingDuration"
        })


#endif

-- method Actor::set_easing_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "AnimationMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "an easing mode, excluding %CLUTTER_CUSTOM_MODE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_easing_mode" clutter_actor_set_easing_mode :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Clutter", name = "AnimationMode"})
    IO ()

-- | Sets the easing mode for the tweening of animatable properties
-- of /@self@/.
-- 
-- /Since: 1.10/
actorSetEasingMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.AnimationMode
    -- ^ /@mode@/: an easing mode, excluding 'GI.Clutter.Enums.AnimationModeCustomMode'
    -> m ()
actorSetEasingMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> AnimationMode -> m ()
actorSetEasingMode a
self AnimationMode
mode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (AnimationMode -> Int) -> AnimationMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AnimationMode -> Int
forall a. Enum a => a -> Int
fromEnum) AnimationMode
mode
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_easing_mode Ptr Actor
self' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetEasingModeMethodInfo
instance (signature ~ (Clutter.Enums.AnimationMode -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetEasingModeMethodInfo a signature where
    overloadedMethod = actorSetEasingMode

instance O.OverloadedMethodInfo ActorSetEasingModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetEasingMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetEasingMode"
        })


#endif

-- method Actor::set_fixed_position_set
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_set"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to use fixed position"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_fixed_position_set" clutter_actor_set_fixed_position_set :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CInt ->                                 -- is_set : TBasicType TBoolean
    IO ()

-- | Sets whether an actor has a fixed position set (and will thus be
-- unaffected by any layout manager).
-- 
-- /Since: 0.8/
actorSetFixedPositionSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Bool
    -- ^ /@isSet@/: whether to use fixed position
    -> m ()
actorSetFixedPositionSet :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Bool -> m ()
actorSetFixedPositionSet a
self Bool
isSet = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let isSet' :: CInt
isSet' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isSet
    Ptr Actor -> CInt -> IO ()
clutter_actor_set_fixed_position_set Ptr Actor
self' CInt
isSet'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetFixedPositionSetMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetFixedPositionSetMethodInfo a signature where
    overloadedMethod = actorSetFixedPositionSet

instance O.OverloadedMethodInfo ActorSetFixedPositionSetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetFixedPositionSet",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetFixedPositionSet"
        })


#endif

-- method Actor::set_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the flags to set" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_flags" clutter_actor_set_flags :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "ActorFlags"})
    IO ()

-- | Sets /@flags@/ on /@self@/
-- 
-- This function will emit notifications for the changed properties
-- 
-- /Since: 1.0/
actorSetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> [Clutter.Flags.ActorFlags]
    -- ^ /@flags@/: the flags to set
    -> m ()
actorSetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> [ActorFlags] -> m ()
actorSetFlags a
self [ActorFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let flags' :: CUInt
flags' = [ActorFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ActorFlags]
flags
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_flags Ptr Actor
self' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetFlagsMethodInfo
instance (signature ~ ([Clutter.Flags.ActorFlags] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetFlagsMethodInfo a signature where
    overloadedMethod = actorSetFlags

instance O.OverloadedMethodInfo ActorSetFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetFlags"
        })


#endif

-- method Actor::set_geometry
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "geometry"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Geometry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterGeometry" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_geometry" clutter_actor_set_geometry :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Geometry.Geometry ->        -- geometry : TInterface (Name {namespace = "Clutter", name = "Geometry"})
    IO ()

{-# DEPRECATED actorSetGeometry ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorSetPosition' and","  'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorSetPosition'
-- and 'GI.Clutter.Objects.Actor.actorSetSize'.
actorSetGeometry ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Geometry.Geometry
    -- ^ /@geometry@/: A t'GI.Clutter.Structs.Geometry.Geometry'
    -> m ()
actorSetGeometry :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Geometry -> m ()
actorSetGeometry a
self Geometry
geometry = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Geometry
geometry' <- Geometry -> IO (Ptr Geometry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Geometry
geometry
    Ptr Actor -> Ptr Geometry -> IO ()
clutter_actor_set_geometry Ptr Actor
self' Ptr Geometry
geometry'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Geometry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Geometry
geometry
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetGeometryMethodInfo
instance (signature ~ (Clutter.Geometry.Geometry -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetGeometryMethodInfo a signature where
    overloadedMethod = actorSetGeometry

instance O.OverloadedMethodInfo ActorSetGeometryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetGeometry",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetGeometry"
        })


#endif

-- method Actor::set_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Requested new height for the actor, in pixels, or -1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_height" clutter_actor_set_height :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- height : TBasicType TFloat
    IO ()

-- | 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/
actorSetHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@height@/: Requested new height for the actor, in pixels, or -1
    -> m ()
actorSetHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetHeight a
self Float
height = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let height' :: CFloat
height' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
height
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_height Ptr Actor
self' CFloat
height'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetHeightMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetHeightMethodInfo a signature where
    overloadedMethod = actorSetHeight

instance O.OverloadedMethodInfo ActorSetHeightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetHeight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetHeight"
        })


#endif

-- method Actor::set_layout_manager
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "manager"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "LayoutManager" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterLayoutManager, or %NULL to unset it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_layout_manager" clutter_actor_set_layout_manager :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.LayoutManager.LayoutManager -> -- manager : TInterface (Name {namespace = "Clutter", name = "LayoutManager"})
    IO ()

-- | Sets the t'GI.Clutter.Objects.LayoutManager.LayoutManager' delegate object that will be used to
-- lay out the children of /@self@/.
-- 
-- The t'GI.Clutter.Objects.Actor.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/
actorSetLayoutManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.LayoutManager.IsLayoutManager b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (b)
    -- ^ /@manager@/: a t'GI.Clutter.Objects.LayoutManager.LayoutManager', or 'P.Nothing' to unset it
    -> m ()
actorSetLayoutManager :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsLayoutManager b) =>
a -> Maybe b -> m ()
actorSetLayoutManager a
self Maybe b
manager = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr LayoutManager
maybeManager <- case Maybe b
manager of
        Maybe b
Nothing -> Ptr LayoutManager -> IO (Ptr LayoutManager)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr LayoutManager
forall a. Ptr a
nullPtr
        Just b
jManager -> do
            Ptr LayoutManager
jManager' <- b -> IO (Ptr LayoutManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jManager
            Ptr LayoutManager -> IO (Ptr LayoutManager)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr LayoutManager
jManager'
    Ptr Actor -> Ptr LayoutManager -> IO ()
clutter_actor_set_layout_manager Ptr Actor
self' Ptr LayoutManager
maybeManager
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
manager b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetLayoutManagerMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActor a, Clutter.LayoutManager.IsLayoutManager b) => O.OverloadedMethod ActorSetLayoutManagerMethodInfo a signature where
    overloadedMethod = actorSetLayoutManager

instance O.OverloadedMethodInfo ActorSetLayoutManagerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetLayoutManager",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetLayoutManager"
        })


#endif

-- method Actor::set_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Margin" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterMargin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_margin" clutter_actor_set_margin :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Margin.Margin ->            -- margin : TInterface (Name {namespace = "Clutter", name = "Margin"})
    IO ()

-- | Sets all the components of the margin of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- /Since: 1.10/
actorSetMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Margin.Margin
    -- ^ /@margin@/: a t'GI.Clutter.Structs.Margin.Margin'
    -> m ()
actorSetMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Margin -> m ()
actorSetMargin a
self Margin
margin = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Margin
margin' <- Margin -> IO (Ptr Margin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Margin
margin
    Ptr Actor -> Ptr Margin -> IO ()
clutter_actor_set_margin Ptr Actor
self' Ptr Margin
margin'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Margin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Margin
margin
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetMarginMethodInfo
instance (signature ~ (Clutter.Margin.Margin -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetMarginMethodInfo a signature where
    overloadedMethod = actorSetMargin

instance O.OverloadedMethodInfo ActorSetMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetMargin"
        })


#endif

-- method Actor::set_margin_bottom
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the bottom margin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_margin_bottom" clutter_actor_set_margin_bottom :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- margin : TBasicType TFloat
    IO ()

-- | Sets the margin from the bottom of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- The [Actor:marginBottom]("GI.Clutter.Objects.Actor#g:attr:marginBottom") property is animatable.
-- 
-- /Since: 1.10/
actorSetMarginBottom ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@margin@/: the bottom margin
    -> m ()
actorSetMarginBottom :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetMarginBottom a
self Float
margin = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let margin' :: CFloat
margin' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
margin
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_margin_bottom Ptr Actor
self' CFloat
margin'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetMarginBottomMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetMarginBottomMethodInfo a signature where
    overloadedMethod = actorSetMarginBottom

instance O.OverloadedMethodInfo ActorSetMarginBottomMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetMarginBottom",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetMarginBottom"
        })


#endif

-- method Actor::set_margin_left
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the left margin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_margin_left" clutter_actor_set_margin_left :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- margin : TBasicType TFloat
    IO ()

-- | Sets the margin from the left of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- The [Actor:marginLeft]("GI.Clutter.Objects.Actor#g:attr:marginLeft") property is animatable.
-- 
-- /Since: 1.10/
actorSetMarginLeft ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@margin@/: the left margin
    -> m ()
actorSetMarginLeft :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetMarginLeft a
self Float
margin = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let margin' :: CFloat
margin' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
margin
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_margin_left Ptr Actor
self' CFloat
margin'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetMarginLeftMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetMarginLeftMethodInfo a signature where
    overloadedMethod = actorSetMarginLeft

instance O.OverloadedMethodInfo ActorSetMarginLeftMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetMarginLeft",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetMarginLeft"
        })


#endif

-- method Actor::set_margin_right
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the right margin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_margin_right" clutter_actor_set_margin_right :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- margin : TBasicType TFloat
    IO ()

-- | Sets the margin from the right of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- The [Actor:marginRight]("GI.Clutter.Objects.Actor#g:attr:marginRight") property is animatable.
-- 
-- /Since: 1.10/
actorSetMarginRight ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@margin@/: the right margin
    -> m ()
actorSetMarginRight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetMarginRight a
self Float
margin = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let margin' :: CFloat
margin' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
margin
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_margin_right Ptr Actor
self' CFloat
margin'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetMarginRightMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetMarginRightMethodInfo a signature where
    overloadedMethod = actorSetMarginRight

instance O.OverloadedMethodInfo ActorSetMarginRightMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetMarginRight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetMarginRight"
        })


#endif

-- method Actor::set_margin_top
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "margin"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the top margin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_margin_top" clutter_actor_set_margin_top :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- margin : TBasicType TFloat
    IO ()

-- | Sets the margin from the top of a t'GI.Clutter.Objects.Actor.Actor'.
-- 
-- The [Actor:marginTop]("GI.Clutter.Objects.Actor#g:attr:marginTop") property is animatable.
-- 
-- /Since: 1.10/
actorSetMarginTop ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@margin@/: the top margin
    -> m ()
actorSetMarginTop :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetMarginTop a
self Float
margin = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let margin' :: CFloat
margin' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
margin
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_margin_top Ptr Actor
self' CFloat
margin'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetMarginTopMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetMarginTopMethodInfo a signature where
    overloadedMethod = actorSetMarginTop

instance O.OverloadedMethodInfo ActorSetMarginTopMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetMarginTop",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetMarginTop"
        })


#endif

-- method Actor::set_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Textual tag to apply to actor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_name" clutter_actor_set_name :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Sets the given name to /@self@/. The name can be used to identify
-- a t'GI.Clutter.Objects.Actor.Actor'.
actorSetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@name@/: Textual tag to apply to actor
    -> m ()
actorSetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> m ()
actorSetName a
self Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Actor -> CString -> IO ()
clutter_actor_set_name Ptr Actor
self' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetNameMethodInfo a signature where
    overloadedMethod = actorSetName

instance O.OverloadedMethodInfo ActorSetNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetName"
        })


#endif

-- method Actor::set_offscreen_redirect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "redirect"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "OffscreenRedirect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "New offscreen redirect flags for the actor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_offscreen_redirect" clutter_actor_set_offscreen_redirect :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- redirect : TInterface (Name {namespace = "Clutter", name = "OffscreenRedirect"})
    IO ()

-- | 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 t'GI.Clutter.Objects.Texture.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
-- 'GI.Clutter.Flags.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 'P.False'
-- for maximum efficiency.
-- 
-- /Since: 1.8/
actorSetOffscreenRedirect ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> [Clutter.Flags.OffscreenRedirect]
    -- ^ /@redirect@/: New offscreen redirect flags for the actor.
    -> m ()
actorSetOffscreenRedirect :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> [OffscreenRedirect] -> m ()
actorSetOffscreenRedirect a
self [OffscreenRedirect]
redirect = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let redirect' :: CUInt
redirect' = [OffscreenRedirect] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [OffscreenRedirect]
redirect
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_offscreen_redirect Ptr Actor
self' CUInt
redirect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetOffscreenRedirectMethodInfo
instance (signature ~ ([Clutter.Flags.OffscreenRedirect] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetOffscreenRedirectMethodInfo a signature where
    overloadedMethod = actorSetOffscreenRedirect

instance O.OverloadedMethodInfo ActorSetOffscreenRedirectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetOffscreenRedirect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetOffscreenRedirect"
        })


#endif

-- method Actor::set_opacity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "opacity"
--           , argType = TBasicType TUInt8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "New opacity value for the actor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_opacity" clutter_actor_set_opacity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Word8 ->                                -- opacity : TBasicType TUInt8
    IO ()

-- | Sets the actor\'s opacity, with zero being completely transparent and
-- 255 (0xff) being fully opaque.
-- 
-- The [Actor:opacity]("GI.Clutter.Objects.Actor#g:attr:opacity") property is animatable.
actorSetOpacity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Word8
    -- ^ /@opacity@/: New opacity value for the actor.
    -> m ()
actorSetOpacity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Word8 -> m ()
actorSetOpacity a
self Word8
opacity = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> Word8 -> IO ()
clutter_actor_set_opacity Ptr Actor
self' Word8
opacity
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetOpacityMethodInfo
instance (signature ~ (Word8 -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetOpacityMethodInfo a signature where
    overloadedMethod = actorSetOpacity

instance O.OverloadedMethodInfo ActorSetOpacityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetOpacity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetOpacity"
        })


#endif

-- method Actor::set_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A new #ClutterActor parent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_parent" clutter_actor_set_parent :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Actor ->                            -- parent : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorSetParent ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.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 'GI.Clutter.Objects.Actor.actorUnparent'.
-- 
-- This function should only be called by legacy t'GI.Clutter.Objects.Actor.Actor's
-- implementing the t'GI.Clutter.Interfaces.Container.Container' interface.
actorSetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, IsActor b) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> b
    -- ^ /@parent@/: A new t'GI.Clutter.Objects.Actor.Actor' parent
    -> m ()
actorSetParent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsActor b) =>
a -> b -> m ()
actorSetParent a
self b
parent = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor
parent' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
parent
    Ptr Actor -> Ptr Actor -> IO ()
clutter_actor_set_parent Ptr Actor
self' Ptr Actor
parent'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
parent
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetParentMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActor a, IsActor b) => O.OverloadedMethod ActorSetParentMethodInfo a signature where
    overloadedMethod = actorSetParent

instance O.OverloadedMethodInfo ActorSetParentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetParent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetParent"
        })


#endif

-- method Actor::set_pivot_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pivot_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the normalized X coordinate of the pivot point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pivot_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the normalized Y coordinate of the pivot point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_pivot_point" clutter_actor_set_pivot_point :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- pivot_x : TBasicType TFloat
    CFloat ->                               -- pivot_y : TBasicType TFloat
    IO ()

-- | Sets the position of the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint") 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/
actorSetPivotPoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@pivotX@/: the normalized X coordinate of the pivot point
    -> Float
    -- ^ /@pivotY@/: the normalized Y coordinate of the pivot point
    -> m ()
actorSetPivotPoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> m ()
actorSetPivotPoint a
self Float
pivotX Float
pivotY = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let pivotX' :: CFloat
pivotX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
pivotX
    let pivotY' :: CFloat
pivotY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
pivotY
    Ptr Actor -> CFloat -> CFloat -> IO ()
clutter_actor_set_pivot_point Ptr Actor
self' CFloat
pivotX' CFloat
pivotY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetPivotPointMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetPivotPointMethodInfo a signature where
    overloadedMethod = actorSetPivotPoint

instance O.OverloadedMethodInfo ActorSetPivotPointMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetPivotPoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetPivotPoint"
        })


#endif

-- method Actor::set_pivot_point_z
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pivot_z"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Z coordinate of the actor's pivot point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_pivot_point_z" clutter_actor_set_pivot_point_z :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- pivot_z : TBasicType TFloat
    IO ()

-- | Sets the component on the Z axis of the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint") around
-- which the scaling and rotation transformations occur.
-- 
-- The /@pivotZ@/ value is expressed as a distance along the Z axis.
-- 
-- /Since: 1.12/
actorSetPivotPointZ ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@pivotZ@/: the Z coordinate of the actor\'s pivot point
    -> m ()
actorSetPivotPointZ :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetPivotPointZ a
self Float
pivotZ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let pivotZ' :: CFloat
pivotZ' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
pivotZ
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_pivot_point_z Ptr Actor
self' CFloat
pivotZ'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetPivotPointZMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetPivotPointZMethodInfo a signature where
    overloadedMethod = actorSetPivotPointZ

instance O.OverloadedMethodInfo ActorSetPivotPointZMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetPivotPointZ",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetPivotPointZ"
        })


#endif

-- method Actor::set_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "New left position of actor in pixels."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "New top position of actor in pixels."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_position" clutter_actor_set_position :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | 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.
actorSetPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@x@/: New left position of actor in pixels.
    -> Float
    -- ^ /@y@/: New top position of actor in pixels.
    -> m ()
actorSetPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> m ()
actorSetPosition a
self Float
x Float
y = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    Ptr Actor -> CFloat -> CFloat -> IO ()
clutter_actor_set_position Ptr Actor
self' CFloat
x' CFloat
y'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetPositionMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetPositionMethodInfo a signature where
    overloadedMethod = actorSetPosition

instance O.OverloadedMethodInfo ActorSetPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetPosition"
        })


#endif

-- method Actor::set_reactive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reactive"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether the actor should be reactive to events"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_reactive" clutter_actor_set_reactive :: 
    Ptr Actor ->                            -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CInt ->                                 -- reactive : TBasicType TBoolean
    IO ()

-- | Sets /@actor@/ as reactive. Reactive actors will receive events.
-- 
-- /Since: 0.6/
actorSetReactive ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Bool
    -- ^ /@reactive@/: whether the actor should be reactive to events
    -> m ()
actorSetReactive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Bool -> m ()
actorSetReactive a
actor Bool
reactive = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    let reactive' :: CInt
reactive' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
reactive
    Ptr Actor -> CInt -> IO ()
clutter_actor_set_reactive Ptr Actor
actor' CInt
reactive'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetReactiveMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetReactiveMethodInfo a signature where
    overloadedMethod = actorSetReactive

instance O.OverloadedMethodInfo ActorSetReactiveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetReactive",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetReactive"
        })


#endif

-- method Actor::set_request_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "RequestMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the request mode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_request_mode" clutter_actor_set_request_mode :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Clutter", name = "RequestMode"})
    IO ()

-- | Sets the geometry request mode of /@self@/.
-- 
-- The /@mode@/ determines the order for invoking
-- 'GI.Clutter.Objects.Actor.actorGetPreferredWidth' and
-- 'GI.Clutter.Objects.Actor.actorGetPreferredHeight'
-- 
-- /Since: 1.2/
actorSetRequestMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.RequestMode
    -- ^ /@mode@/: the request mode
    -> m ()
actorSetRequestMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> RequestMode -> m ()
actorSetRequestMode a
self RequestMode
mode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (RequestMode -> Int) -> RequestMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RequestMode -> Int
forall a. Enum a => a -> Int
fromEnum) RequestMode
mode
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_request_mode Ptr Actor
self' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetRequestModeMethodInfo
instance (signature ~ (Clutter.Enums.RequestMode -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetRequestModeMethodInfo a signature where
    overloadedMethod = actorSetRequestMode

instance O.OverloadedMethodInfo ActorSetRequestModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetRequestMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetRequestMode"
        })


#endif

-- method Actor::set_rotation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "axis"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "RotateAxis" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the axis of rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the angle of rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "X coordinate of the rotation center"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Y coordinate of the rotation center"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "z"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Z coordinate of the rotation center"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_rotation" clutter_actor_set_rotation :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- axis : TInterface (Name {namespace = "Clutter", name = "RotateAxis"})
    CDouble ->                              -- angle : TBasicType TDouble
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    CFloat ->                               -- z : TBasicType TFloat
    IO ()

{-# DEPRECATED actorSetRotation ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.actorSetRotationAngle' and","  'GI.Clutter.Objects.Actor.actorSetPivotPoint' instead."] #-}
-- | Sets the rotation angle of /@self@/ around the given axis.
-- 
-- The rotation center coordinates used depend on the value of /@axis@/:
-- 
--  - 'GI.Clutter.Enums.RotateAxisXAxis' requires /@y@/ and /@z@/
--  - 'GI.Clutter.Enums.RotateAxisYAxis' requires /@x@/ and /@z@/
--  - 'GI.Clutter.Enums.RotateAxisZAxis' requires /@x@/ and /@y@/
-- 
-- The rotation coordinates are relative to the anchor point of the
-- actor, set using 'GI.Clutter.Objects.Actor.actorSetAnchorPoint'. If no anchor
-- point is set, the upper left corner is assumed as the origin.
-- 
-- /Since: 0.8/
actorSetRotation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.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 ()
actorSetRotation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> RotateAxis -> Double -> Float -> Float -> Float -> m ()
actorSetRotation a
self RotateAxis
axis Double
angle Float
x Float
y Float
z = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let axis' :: CUInt
axis' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (RotateAxis -> Int) -> RotateAxis -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RotateAxis -> Int
forall a. Enum a => a -> Int
fromEnum) RotateAxis
axis
    let angle' :: CDouble
angle' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
angle
    let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    let z' :: CFloat
z' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z
    Ptr Actor
-> CUInt -> CDouble -> CFloat -> CFloat -> CFloat -> IO ()
clutter_actor_set_rotation Ptr Actor
self' CUInt
axis' CDouble
angle' CFloat
x' CFloat
y' CFloat
z'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetRotationMethodInfo
instance (signature ~ (Clutter.Enums.RotateAxis -> Double -> Float -> Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetRotationMethodInfo a signature where
    overloadedMethod = actorSetRotation

instance O.OverloadedMethodInfo ActorSetRotationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetRotation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetRotation"
        })


#endif

-- method Actor::set_rotation_angle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "axis"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "RotateAxis" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the axis to set the angle one"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the angle of rotation, in degrees"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_rotation_angle" clutter_actor_set_rotation_angle :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- axis : TInterface (Name {namespace = "Clutter", name = "RotateAxis"})
    CDouble ->                              -- angle : TBasicType TDouble
    IO ()

-- | Sets the /@angle@/ of rotation of a t'GI.Clutter.Objects.Actor.Actor' on the given /@axis@/.
-- 
-- This function is a convenience for setting the rotation properties
-- [Actor:rotationAngleX]("GI.Clutter.Objects.Actor#g:attr:rotationAngleX"), [Actor:rotationAngleY]("GI.Clutter.Objects.Actor#g:attr:rotationAngleY"),
-- and [Actor:rotationAngleZ]("GI.Clutter.Objects.Actor#g:attr:rotationAngleZ").
-- 
-- The center of rotation is established by the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint")
-- property.
-- 
-- /Since: 1.12/
actorSetRotationAngle ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.RotateAxis
    -- ^ /@axis@/: the axis to set the angle one
    -> Double
    -- ^ /@angle@/: the angle of rotation, in degrees
    -> m ()
actorSetRotationAngle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> RotateAxis -> Double -> m ()
actorSetRotationAngle a
self RotateAxis
axis Double
angle = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let axis' :: CUInt
axis' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (RotateAxis -> Int) -> RotateAxis -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RotateAxis -> Int
forall a. Enum a => a -> Int
fromEnum) RotateAxis
axis
    let angle' :: CDouble
angle' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
angle
    Ptr Actor -> CUInt -> CDouble -> IO ()
clutter_actor_set_rotation_angle Ptr Actor
self' CUInt
axis' CDouble
angle'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetRotationAngleMethodInfo
instance (signature ~ (Clutter.Enums.RotateAxis -> Double -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetRotationAngleMethodInfo a signature where
    overloadedMethod = actorSetRotationAngle

instance O.OverloadedMethodInfo ActorSetRotationAngleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetRotationAngle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetRotationAngle"
        })


#endif

-- method Actor::set_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale_x"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "double factor to scale actor by horizontally."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale_y"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "double factor to scale actor by vertically."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_scale" clutter_actor_set_scale :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CDouble ->                              -- scale_x : TBasicType TDouble
    CDouble ->                              -- scale_y : TBasicType TDouble
    IO ()

-- | Scales an actor with the given factors.
-- 
-- The scale transformation is relative the the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- The [Actor:scaleX]("GI.Clutter.Objects.Actor#g:attr:scaleX") and [Actor:scaleY]("GI.Clutter.Objects.Actor#g:attr:scaleY") properties are
-- animatable.
-- 
-- /Since: 0.2/
actorSetScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Double
    -- ^ /@scaleX@/: double factor to scale actor by horizontally.
    -> Double
    -- ^ /@scaleY@/: double factor to scale actor by vertically.
    -> m ()
actorSetScale :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Double -> Double -> m ()
actorSetScale a
self Double
scaleX Double
scaleY = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let scaleX' :: CDouble
scaleX' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scaleX
    let scaleY' :: CDouble
scaleY' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scaleY
    Ptr Actor -> CDouble -> CDouble -> IO ()
clutter_actor_set_scale Ptr Actor
self' CDouble
scaleX' CDouble
scaleY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetScaleMethodInfo
instance (signature ~ (Double -> Double -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetScaleMethodInfo a signature where
    overloadedMethod = actorSetScale

instance O.OverloadedMethodInfo ActorSetScaleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetScale",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetScale"
        })


#endif

-- method Actor::set_scale_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale_x"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "double factor to scale actor by horizontally."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale_y"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "double factor to scale actor by vertically."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "center_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "X coordinate of the center of the scaling"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "center_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Y coordinate of the center of the scaling"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_scale_full" clutter_actor_set_scale_full :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CDouble ->                              -- scale_x : TBasicType TDouble
    CDouble ->                              -- scale_y : TBasicType TDouble
    CFloat ->                               -- center_x : TBasicType TFloat
    CFloat ->                               -- center_y : TBasicType TFloat
    IO ()

{-# DEPRECATED actorSetScaleFull ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.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:scaleX]("GI.Clutter.Objects.Actor#g:attr:scaleX") and [Actor:scaleY]("GI.Clutter.Objects.Actor#g:attr:scaleY") properties
-- are animatable.
-- 
-- /Since: 1.0/
actorSetScaleFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.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 ()
actorSetScaleFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Double -> Double -> Float -> Float -> m ()
actorSetScaleFull a
self Double
scaleX Double
scaleY Float
centerX Float
centerY = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let scaleX' :: CDouble
scaleX' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scaleX
    let scaleY' :: CDouble
scaleY' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scaleY
    let centerX' :: CFloat
centerX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
centerX
    let centerY' :: CFloat
centerY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
centerY
    Ptr Actor -> CDouble -> CDouble -> CFloat -> CFloat -> IO ()
clutter_actor_set_scale_full Ptr Actor
self' CDouble
scaleX' CDouble
scaleY' CFloat
centerX' CFloat
centerY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetScaleFullMethodInfo
instance (signature ~ (Double -> Double -> Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetScaleFullMethodInfo a signature where
    overloadedMethod = actorSetScaleFull

instance O.OverloadedMethodInfo ActorSetScaleFullMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetScaleFull",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetScaleFull"
        })


#endif

-- method Actor::set_scale_with_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale_x"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "double factor to scale actor by horizontally."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale_y"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "double factor to scale actor by vertically."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gravity"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Gravity" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the location of the scale center expressed as a compass\n  direction."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_scale_with_gravity" clutter_actor_set_scale_with_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CDouble ->                              -- scale_x : TBasicType TDouble
    CDouble ->                              -- scale_y : TBasicType TDouble
    CUInt ->                                -- gravity : TInterface (Name {namespace = "Clutter", name = "Gravity"})
    IO ()

{-# DEPRECATED actorSetScaleWithGravity ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.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 t'GI.Clutter.Enums.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:scaleX]("GI.Clutter.Objects.Actor#g:attr:scaleX") and [Actor:scaleY]("GI.Clutter.Objects.Actor#g:attr:scaleY") properties are
-- animatable.
-- 
-- /Since: 1.0/
actorSetScaleWithGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Double
    -- ^ /@scaleX@/: double factor to scale actor by horizontally.
    -> Double
    -- ^ /@scaleY@/: double factor to scale actor by vertically.
    -> Clutter.Enums.Gravity
    -- ^ /@gravity@/: the location of the scale center expressed as a compass
    --   direction.
    -> m ()
actorSetScaleWithGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Double -> Double -> Gravity -> m ()
actorSetScaleWithGravity a
self Double
scaleX Double
scaleY Gravity
gravity = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let scaleX' :: CDouble
scaleX' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scaleX
    let scaleY' :: CDouble
scaleY' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scaleY
    let gravity' :: CUInt
gravity' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Gravity -> Int) -> Gravity -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gravity -> Int
forall a. Enum a => a -> Int
fromEnum) Gravity
gravity
    Ptr Actor -> CDouble -> CDouble -> CUInt -> IO ()
clutter_actor_set_scale_with_gravity Ptr Actor
self' CDouble
scaleX' CDouble
scaleY' CUInt
gravity'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetScaleWithGravityMethodInfo
instance (signature ~ (Double -> Double -> Clutter.Enums.Gravity -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetScaleWithGravityMethodInfo a signature where
    overloadedMethod = actorSetScaleWithGravity

instance O.OverloadedMethodInfo ActorSetScaleWithGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetScaleWithGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetScaleWithGravity"
        })


#endif

-- method Actor::set_scale_z
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scale_z"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the scaling factor along the Z axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_scale_z" clutter_actor_set_scale_z :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CDouble ->                              -- scale_z : TBasicType TDouble
    IO ()

-- | Scales an actor on the Z axis by the given /@scaleZ@/ factor.
-- 
-- The scale transformation is relative the the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- The [Actor:scaleZ]("GI.Clutter.Objects.Actor#g:attr:scaleZ") property is animatable.
-- 
-- /Since: 1.12/
actorSetScaleZ ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Double
    -- ^ /@scaleZ@/: the scaling factor along the Z axis
    -> m ()
actorSetScaleZ :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Double -> m ()
actorSetScaleZ a
self Double
scaleZ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let scaleZ' :: CDouble
scaleZ' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
scaleZ
    Ptr Actor -> CDouble -> IO ()
clutter_actor_set_scale_z Ptr Actor
self' CDouble
scaleZ'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetScaleZMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetScaleZMethodInfo a signature where
    overloadedMethod = actorSetScaleZ

instance O.OverloadedMethodInfo ActorSetScaleZMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetScaleZ",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetScaleZ"
        })


#endif

-- method Actor::set_shader
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "shader"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Shader" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #ClutterShader or %NULL to unset the shader."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_shader" clutter_actor_set_shader :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Shader.Shader ->            -- shader : TInterface (Name {namespace = "Clutter", name = "Shader"})
    IO CInt

{-# DEPRECATED actorSetShader ["(Since version 1.8)","Use t'GI.Clutter.Objects.ShaderEffect.ShaderEffect' and","  'GI.Clutter.Objects.Actor.actorAddEffect' instead."] #-}
-- | Sets the t'GI.Clutter.Objects.Shader.Shader' to be used when rendering /@self@/.
-- 
-- If /@shader@/ is 'P.Nothing' this function will unset any currently set shader
-- for the actor.
-- 
-- Any t'GI.Clutter.Objects.Effect.Effect' applied to /@self@/ will take the precedence
-- over the t'GI.Clutter.Objects.Shader.Shader' set using this function.
-- 
-- /Since: 0.6/
actorSetShader ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a, Clutter.Shader.IsShader b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (b)
    -- ^ /@shader@/: a t'GI.Clutter.Objects.Shader.Shader' or 'P.Nothing' to unset the shader.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the shader was successfully applied
    --   or removed
actorSetShader :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActor a, IsShader b) =>
a -> Maybe b -> m Bool
actorSetShader a
self Maybe b
shader = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Shader
maybeShader <- case Maybe b
shader of
        Maybe b
Nothing -> Ptr Shader -> IO (Ptr Shader)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Shader
forall a. Ptr a
nullPtr
        Just b
jShader -> do
            Ptr Shader
jShader' <- b -> IO (Ptr Shader)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jShader
            Ptr Shader -> IO (Ptr Shader)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Shader
jShader'
    CInt
result <- Ptr Actor -> Ptr Shader -> IO CInt
clutter_actor_set_shader Ptr Actor
self' Ptr Shader
maybeShader
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
shader b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorSetShaderMethodInfo
instance (signature ~ (Maybe (b) -> m Bool), MonadIO m, IsActor a, Clutter.Shader.IsShader b) => O.OverloadedMethod ActorSetShaderMethodInfo a signature where
    overloadedMethod = actorSetShader

instance O.OverloadedMethodInfo ActorSetShaderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetShader",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetShader"
        })


#endif

-- method Actor::set_shader_param
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "param"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the parameter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value of the parameter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_shader_param" clutter_actor_set_shader_param :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- param : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    IO ()

{-# DEPRECATED actorSetShaderParam ["(Since version 1.8)","Use 'GI.Clutter.Objects.ShaderEffect.shaderEffectSetUniformValue' instead"] #-}
-- | Sets the value for a named parameter of the shader applied
-- to /@actor@/.
-- 
-- /Since: 1.0/
actorSetShaderParam ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@param@/: the name of the parameter
    -> GValue
    -- ^ /@value@/: the value of the parameter
    -> m ()
actorSetShaderParam :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> GValue -> m ()
actorSetShaderParam a
self Text
param GValue
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
param' <- Text -> IO CString
textToCString Text
param
    Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    Ptr Actor -> CString -> Ptr GValue -> IO ()
clutter_actor_set_shader_param Ptr Actor
self' CString
param' Ptr GValue
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
param'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetShaderParamMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetShaderParamMethodInfo a signature where
    overloadedMethod = actorSetShaderParam

instance O.OverloadedMethodInfo ActorSetShaderParamMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetShaderParam",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetShaderParam"
        })


#endif

-- method Actor::set_shader_param_float
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "param"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the parameter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value of the parameter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_shader_param_float" clutter_actor_set_shader_param_float :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- param : TBasicType TUTF8
    CFloat ->                               -- value : TBasicType TFloat
    IO ()

{-# DEPRECATED actorSetShaderParamFloat ["(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/
actorSetShaderParamFloat ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@param@/: the name of the parameter
    -> Float
    -- ^ /@value@/: the value of the parameter
    -> m ()
actorSetShaderParamFloat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> Float -> m ()
actorSetShaderParamFloat a
self Text
param Float
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
param' <- Text -> IO CString
textToCString Text
param
    let value' :: CFloat
value' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
value
    Ptr Actor -> CString -> CFloat -> IO ()
clutter_actor_set_shader_param_float Ptr Actor
self' CString
param' CFloat
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
param'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetShaderParamFloatMethodInfo
instance (signature ~ (T.Text -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetShaderParamFloatMethodInfo a signature where
    overloadedMethod = actorSetShaderParamFloat

instance O.OverloadedMethodInfo ActorSetShaderParamFloatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetShaderParamFloat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetShaderParamFloat"
        })


#endif

-- method Actor::set_shader_param_int
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "param"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the parameter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value of the parameter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_shader_param_int" clutter_actor_set_shader_param_int :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CString ->                              -- param : TBasicType TUTF8
    Int32 ->                                -- value : TBasicType TInt
    IO ()

{-# DEPRECATED actorSetShaderParamInt ["(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/
actorSetShaderParamInt ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> T.Text
    -- ^ /@param@/: the name of the parameter
    -> Int32
    -- ^ /@value@/: the value of the parameter
    -> m ()
actorSetShaderParamInt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Text -> Int32 -> m ()
actorSetShaderParamInt a
self Text
param Int32
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
param' <- Text -> IO CString
textToCString Text
param
    Ptr Actor -> CString -> Int32 -> IO ()
clutter_actor_set_shader_param_int Ptr Actor
self' CString
param' Int32
value
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
param'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetShaderParamIntMethodInfo
instance (signature ~ (T.Text -> Int32 -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetShaderParamIntMethodInfo a signature where
    overloadedMethod = actorSetShaderParamInt

instance O.OverloadedMethodInfo ActorSetShaderParamIntMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetShaderParamInt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetShaderParamInt"
        })


#endif

-- method Actor::set_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "New width of actor in pixels, or -1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "New height of actor in pixels, or -1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_size" clutter_actor_set_size :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- width : TBasicType TFloat
    CFloat ->                               -- height : TBasicType TFloat
    IO ()

-- | 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.
actorSetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@width@/: New width of actor in pixels, or -1
    -> Float
    -- ^ /@height@/: New height of actor in pixels, or -1
    -> m ()
actorSetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> m ()
actorSetSize a
self Float
width Float
height = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let width' :: CFloat
width' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
width
    let height' :: CFloat
height' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
height
    Ptr Actor -> CFloat -> CFloat -> IO ()
clutter_actor_set_size Ptr Actor
self' CFloat
width' CFloat
height'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetSizeMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetSizeMethodInfo a signature where
    overloadedMethod = actorSetSize

instance O.OverloadedMethodInfo ActorSetSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetSize"
        })


#endif

-- method Actor::set_text_direction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text_dir"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "TextDirection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the text direction for @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_text_direction" clutter_actor_set_text_direction :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- text_dir : TInterface (Name {namespace = "Clutter", name = "TextDirection"})
    IO ()

-- | Sets the t'GI.Clutter.Enums.TextDirection' for an actor
-- 
-- The passed text direction must not be 'GI.Clutter.Enums.TextDirectionDefault'
-- 
-- If /@self@/ implements t'GI.Clutter.Interfaces.Container.Container' then this function will recurse
-- inside all the children of /@self@/ (including the internal ones).
-- 
-- Composite actors not implementing t'GI.Clutter.Interfaces.Container.Container', or actors requiring
-- special handling when the text direction changes, should connect to
-- the [Object::notify]("GI.GObject.Objects.Object#g:signal:notify") signal for the [Actor:textDirection]("GI.Clutter.Objects.Actor#g:attr:textDirection") property
-- 
-- /Since: 1.2/
actorSetTextDirection ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.TextDirection
    -- ^ /@textDir@/: the text direction for /@self@/
    -> m ()
actorSetTextDirection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> TextDirection -> m ()
actorSetTextDirection a
self TextDirection
textDir = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let textDir' :: CUInt
textDir' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextDirection -> Int) -> TextDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextDirection -> Int
forall a. Enum a => a -> Int
fromEnum) TextDirection
textDir
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_text_direction Ptr Actor
self' CUInt
textDir'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetTextDirectionMethodInfo
instance (signature ~ (Clutter.Enums.TextDirection -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetTextDirectionMethodInfo a signature where
    overloadedMethod = actorSetTextDirection

instance O.OverloadedMethodInfo ActorSetTextDirectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetTextDirection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetTextDirection"
        })


#endif

-- method Actor::set_transform
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "transform"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Matrix" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterMatrix, or %NULL to\n  unset a custom transformation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_transform" clutter_actor_set_transform :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    Ptr Clutter.Matrix.Matrix ->            -- transform : TInterface (Name {namespace = "Clutter", name = "Matrix"})
    IO ()

-- | Overrides the transformations of a t'GI.Clutter.Objects.Actor.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]("GI.Clutter.Objects.Actor#g:attr:transform") property is animatable.
-- 
-- /Since: 1.12/
actorSetTransform ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Maybe (Clutter.Matrix.Matrix)
    -- ^ /@transform@/: a t'GI.Clutter.Structs.Matrix.Matrix', or 'P.Nothing' to
    --   unset a custom transformation
    -> m ()
actorSetTransform :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Maybe Matrix -> m ()
actorSetTransform a
self Maybe Matrix
transform = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Matrix
maybeTransform <- case Maybe Matrix
transform of
        Maybe Matrix
Nothing -> Ptr Matrix -> IO (Ptr Matrix)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Matrix
forall a. Ptr a
nullPtr
        Just Matrix
jTransform -> do
            Ptr Matrix
jTransform' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
jTransform
            Ptr Matrix -> IO (Ptr Matrix)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Matrix
jTransform'
    Ptr Actor -> Ptr Matrix -> IO ()
clutter_actor_set_transform Ptr Actor
self' Ptr Matrix
maybeTransform
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Matrix -> (Matrix -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Matrix
transform Matrix -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetTransformMethodInfo
instance (signature ~ (Maybe (Clutter.Matrix.Matrix) -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetTransformMethodInfo a signature where
    overloadedMethod = actorSetTransform

instance O.OverloadedMethodInfo ActorSetTransformMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetTransform",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetTransform"
        })


#endif

-- method Actor::set_translation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "translate_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the translation along the X axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "translate_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the translation along the Y axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "translate_z"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the translation along the Z axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_translation" clutter_actor_set_translation :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- translate_x : TBasicType TFloat
    CFloat ->                               -- translate_y : TBasicType TFloat
    CFloat ->                               -- translate_z : TBasicType TFloat
    IO ()

-- | Sets an additional translation transformation on a t'GI.Clutter.Objects.Actor.Actor',
-- relative to the [Actor:pivotPoint]("GI.Clutter.Objects.Actor#g:attr:pivotPoint").
-- 
-- /Since: 1.12/
actorSetTranslation ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.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 ()
actorSetTranslation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> Float -> m ()
actorSetTranslation a
self Float
translateX Float
translateY Float
translateZ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let translateX' :: CFloat
translateX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
translateX
    let translateY' :: CFloat
translateY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
translateY
    let translateZ' :: CFloat
translateZ' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
translateZ
    Ptr Actor -> CFloat -> CFloat -> CFloat -> IO ()
clutter_actor_set_translation Ptr Actor
self' CFloat
translateX' CFloat
translateY' CFloat
translateZ'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetTranslationMethodInfo
instance (signature ~ (Float -> Float -> Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetTranslationMethodInfo a signature where
    overloadedMethod = actorSetTranslation

instance O.OverloadedMethodInfo ActorSetTranslationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetTranslation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetTranslation"
        })


#endif

-- method Actor::set_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Requested new width for the actor, in pixels, or -1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_width" clutter_actor_set_width :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- width : TBasicType TFloat
    IO ()

-- | 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/
actorSetWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@width@/: Requested new width for the actor, in pixels, or -1
    -> m ()
actorSetWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetWidth a
self Float
width = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let width' :: CFloat
width' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
width
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_width Ptr Actor
self' CFloat
width'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetWidthMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetWidthMethodInfo a signature where
    overloadedMethod = actorSetWidth

instance O.OverloadedMethodInfo ActorSetWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetWidth"
        })


#endif

-- method Actor::set_x
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the actor's position on the X axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_x" clutter_actor_set_x :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- x : TBasicType TFloat
    IO ()

-- | 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]("GI.Clutter.Objects.Actor#g:attr:x") property is animatable.
-- 
-- /Since: 0.6/
actorSetX ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@x@/: the actor\'s position on the X axis
    -> m ()
actorSetX :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetX a
self Float
x = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_x Ptr Actor
self' CFloat
x'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetXMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetXMethodInfo a signature where
    overloadedMethod = actorSetX

instance O.OverloadedMethodInfo ActorSetXMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetX",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetX"
        })


#endif

-- method Actor::set_x_align
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x_align"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorAlign" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the horizontal alignment policy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_x_align" clutter_actor_set_x_align :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- x_align : TInterface (Name {namespace = "Clutter", name = "ActorAlign"})
    IO ()

-- | Sets the horizontal alignment policy of a t'GI.Clutter.Objects.Actor.Actor', in case the
-- actor received extra horizontal space.
-- 
-- See also the [Actor:xAlign]("GI.Clutter.Objects.Actor#g:attr:xAlign") property.
-- 
-- /Since: 1.10/
actorSetXAlign ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.ActorAlign
    -- ^ /@xAlign@/: the horizontal alignment policy
    -> m ()
actorSetXAlign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> ActorAlign -> m ()
actorSetXAlign a
self ActorAlign
xAlign = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let xAlign' :: CUInt
xAlign' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ActorAlign -> Int) -> ActorAlign -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ActorAlign -> Int
forall a. Enum a => a -> Int
fromEnum) ActorAlign
xAlign
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_x_align Ptr Actor
self' CUInt
xAlign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetXAlignMethodInfo
instance (signature ~ (Clutter.Enums.ActorAlign -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetXAlignMethodInfo a signature where
    overloadedMethod = actorSetXAlign

instance O.OverloadedMethodInfo ActorSetXAlignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetXAlign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetXAlign"
        })


#endif

-- method Actor::set_x_expand
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expand"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the actor should expand horizontally"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_x_expand" clutter_actor_set_x_expand :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

-- | Sets whether a t'GI.Clutter.Objects.Actor.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/
actorSetXExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Bool
    -- ^ /@expand@/: whether the actor should expand horizontally
    -> m ()
actorSetXExpand :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Bool -> m ()
actorSetXExpand a
self Bool
expand = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let expand' :: CInt
expand' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
expand
    Ptr Actor -> CInt -> IO ()
clutter_actor_set_x_expand Ptr Actor
self' CInt
expand'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetXExpandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetXExpandMethodInfo a signature where
    overloadedMethod = actorSetXExpand

instance O.OverloadedMethodInfo ActorSetXExpandMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetXExpand",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetXExpand"
        })


#endif

-- method Actor::set_y
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the actor's position on the Y axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_y" clutter_actor_set_y :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | 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]("GI.Clutter.Objects.Actor#g:attr:y") property is animatable.
-- 
-- /Since: 0.6/
actorSetY ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@y@/: the actor\'s position on the Y axis
    -> m ()
actorSetY :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetY a
self Float
y = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_y Ptr Actor
self' CFloat
y'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetYMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetYMethodInfo a signature where
    overloadedMethod = actorSetY

instance O.OverloadedMethodInfo ActorSetYMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetY",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetY"
        })


#endif

-- method Actor::set_y_align
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y_align"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorAlign" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the vertical alignment policy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_y_align" clutter_actor_set_y_align :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- y_align : TInterface (Name {namespace = "Clutter", name = "ActorAlign"})
    IO ()

-- | Sets the vertical alignment policy of a t'GI.Clutter.Objects.Actor.Actor', in case the
-- actor received extra vertical space.
-- 
-- See also the [Actor:yAlign]("GI.Clutter.Objects.Actor#g:attr:yAlign") property.
-- 
-- /Since: 1.10/
actorSetYAlign ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Clutter.Enums.ActorAlign
    -- ^ /@yAlign@/: the vertical alignment policy
    -> m ()
actorSetYAlign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> ActorAlign -> m ()
actorSetYAlign a
self ActorAlign
yAlign = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let yAlign' :: CUInt
yAlign' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ActorAlign -> Int) -> ActorAlign -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ActorAlign -> Int
forall a. Enum a => a -> Int
fromEnum) ActorAlign
yAlign
    Ptr Actor -> CUInt -> IO ()
clutter_actor_set_y_align Ptr Actor
self' CUInt
yAlign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetYAlignMethodInfo
instance (signature ~ (Clutter.Enums.ActorAlign -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetYAlignMethodInfo a signature where
    overloadedMethod = actorSetYAlign

instance O.OverloadedMethodInfo ActorSetYAlignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetYAlign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetYAlign"
        })


#endif

-- method Actor::set_y_expand
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expand"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the actor should expand vertically"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_y_expand" clutter_actor_set_y_expand :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

-- | Sets whether a t'GI.Clutter.Objects.Actor.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/
actorSetYExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Bool
    -- ^ /@expand@/: whether the actor should expand vertically
    -> m ()
actorSetYExpand :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Bool -> m ()
actorSetYExpand a
self Bool
expand = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let expand' :: CInt
expand' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
expand
    Ptr Actor -> CInt -> IO ()
clutter_actor_set_y_expand Ptr Actor
self' CInt
expand'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetYExpandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetYExpandMethodInfo a signature where
    overloadedMethod = actorSetYExpand

instance O.OverloadedMethodInfo ActorSetYExpandMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetYExpand",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetYExpand"
        })


#endif

-- method Actor::set_z_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "z_position"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position on the Z axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_z_position" clutter_actor_set_z_position :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- z_position : TBasicType TFloat
    IO ()

-- | Sets the actor\'s position on the Z axis.
-- 
-- See [Actor:zPosition]("GI.Clutter.Objects.Actor#g:attr:zPosition").
-- 
-- /Since: 1.12/
actorSetZPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Float
    -- ^ /@zPosition@/: the position on the Z axis
    -> m ()
actorSetZPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> m ()
actorSetZPosition a
self Float
zPosition = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let zPosition' :: CFloat
zPosition' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
zPosition
    Ptr Actor -> CFloat -> IO ()
clutter_actor_set_z_position Ptr Actor
self' CFloat
zPosition'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetZPositionMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetZPositionMethodInfo a signature where
    overloadedMethod = actorSetZPosition

instance O.OverloadedMethodInfo ActorSetZPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetZPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetZPosition"
        })


#endif

-- method Actor::set_z_rotation_from_gravity
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "angle"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the angle of rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gravity"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Gravity" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the center point of the rotation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_set_z_rotation_from_gravity" clutter_actor_set_z_rotation_from_gravity :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CDouble ->                              -- angle : TBasicType TDouble
    CUInt ->                                -- gravity : TInterface (Name {namespace = "Clutter", name = "Gravity"})
    IO ()

{-# DEPRECATED actorSetZRotationFromGravity ["(Since version 1.12)","Use 'GI.Clutter.Objects.Actor.actorSetRotationAngle' and","  'GI.Clutter.Objects.Actor.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
-- 'GI.Clutter.Enums.GravityCenter'. If the actor changes size the center point
-- will move accordingly.
-- 
-- /Since: 1.0/
actorSetZRotationFromGravity ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> Double
    -- ^ /@angle@/: the angle of rotation
    -> Clutter.Enums.Gravity
    -- ^ /@gravity@/: the center point of the rotation
    -> m ()
actorSetZRotationFromGravity :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Double -> Gravity -> m ()
actorSetZRotationFromGravity a
self Double
angle Gravity
gravity = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let angle' :: CDouble
angle' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
angle
    let gravity' :: CUInt
gravity' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Gravity -> Int) -> Gravity -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gravity -> Int
forall a. Enum a => a -> Int
fromEnum) Gravity
gravity
    Ptr Actor -> CDouble -> CUInt -> IO ()
clutter_actor_set_z_rotation_from_gravity Ptr Actor
self' CDouble
angle' CUInt
gravity'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorSetZRotationFromGravityMethodInfo
instance (signature ~ (Double -> Clutter.Enums.Gravity -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorSetZRotationFromGravityMethodInfo a signature where
    overloadedMethod = actorSetZRotationFromGravity

instance O.OverloadedMethodInfo ActorSetZRotationFromGravityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorSetZRotationFromGravity",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorSetZRotationFromGravity"
        })


#endif

-- method Actor::should_pick_paint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_should_pick_paint" clutter_actor_should_pick_paint :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO CInt

-- | Should be called inside the implementation of the
-- [Actor::pick]("GI.Clutter.Objects.Actor#g:signal: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.
actorShouldPickPaint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the actor should paint its silhouette,
    --   'P.False' otherwise
actorShouldPickPaint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Bool
actorShouldPickPaint a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Actor -> IO CInt
clutter_actor_should_pick_paint Ptr Actor
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ActorShouldPickPaintMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsActor a) => O.OverloadedMethod ActorShouldPickPaintMethodInfo a signature where
    overloadedMethod = actorShouldPickPaint

instance O.OverloadedMethodInfo ActorShouldPickPaintMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorShouldPickPaint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorShouldPickPaint"
        })


#endif

-- method Actor::show
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_show" clutter_actor_show :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | 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:showOnSetParent]("GI.Clutter.Objects.Actor#g:attr:showOnSetParent") will be set to 'P.True' as a side
-- effect.
actorShow ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorShow :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorShow a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_show Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorShowMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorShowMethodInfo a signature where
    overloadedMethod = actorShow

instance O.OverloadedMethodInfo ActorShowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorShow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorShow"
        })


#endif

-- method Actor::show_all
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_show_all" clutter_actor_show_all :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorShowAll ["(Since version 1.10)","Actors are visible by default"] #-}
-- | Calls 'GI.Clutter.Objects.Actor.actorShow' on all children of an actor (if any).
-- 
-- /Since: 0.2/
actorShowAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorShowAll :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorShowAll a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_show_all Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorShowAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorShowAllMethodInfo a signature where
    overloadedMethod = actorShowAll

instance O.OverloadedMethodInfo ActorShowAllMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorShowAll",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorShowAll"
        })


#endif

-- method Actor::transform_stage_point
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "x screen coordinate of the point to unproject"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "y screen coordinate of the point to unproject"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x_out"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the unprojected x coordinance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y_out"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the unprojected y coordinance"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_transform_stage_point" clutter_actor_transform_stage_point :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    Ptr CFloat ->                           -- x_out : TBasicType TFloat
    Ptr CFloat ->                           -- y_out : TBasicType TFloat
    IO CInt

-- | 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 t'GI.Clutter.Structs.ActorClass.ActorClass'.@/paint/@() implementation
-- 
-- /Since: 0.6/
actorTransformStagePoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.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:__ 'P.True' if conversion was successful.
actorTransformStagePoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> Float -> Float -> m (Bool, Float, Float)
actorTransformStagePoint a
self Float
x Float
y = IO (Bool, Float, Float) -> m (Bool, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Float, Float) -> m (Bool, Float, Float))
-> IO (Bool, Float, Float) -> m (Bool, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    Ptr CFloat
xOut <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
yOut <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    CInt
result <- Ptr Actor
-> CFloat -> CFloat -> Ptr CFloat -> Ptr CFloat -> IO CInt
clutter_actor_transform_stage_point Ptr Actor
self' CFloat
x' CFloat
y' Ptr CFloat
xOut Ptr CFloat
yOut
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CFloat
xOut' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
xOut
    let xOut'' :: Float
xOut'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
xOut'
    CFloat
yOut' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
yOut
    let yOut'' :: Float
yOut'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
yOut'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
xOut
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
yOut
    (Bool, Float, Float) -> IO (Bool, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Float
xOut'', Float
yOut'')

#if defined(ENABLE_OVERLOADING)
data ActorTransformStagePointMethodInfo
instance (signature ~ (Float -> Float -> m ((Bool, Float, Float))), MonadIO m, IsActor a) => O.OverloadedMethod ActorTransformStagePointMethodInfo a signature where
    overloadedMethod = actorTransformStagePoint

instance O.OverloadedMethodInfo ActorTransformStagePointMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorTransformStagePoint",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorTransformStagePoint"
        })


#endif

-- method Actor::unmap
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_unmap" clutter_actor_unmap :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Unsets the 'GI.Clutter.Flags.ActorFlagsMapped' flag on the actor and possibly
-- unmaps its children if they were mapped.
-- 
-- Calling this function is not encouraged: the default t'GI.Clutter.Objects.Actor.Actor'
-- implementation of t'GI.Clutter.Structs.ActorClass.ActorClass'.@/unmap/@() will also unmap any
-- eventual children by default when their parent is unmapped.
-- 
-- When overriding t'GI.Clutter.Structs.ActorClass.ActorClass'.@/unmap/@(), it is mandatory to
-- chain up to the parent implementation.
-- 
-- It is important to note that the implementation of the
-- t'GI.Clutter.Structs.ActorClass.ActorClass'.@/unmap/@() virtual function may be called after
-- the t'GI.Clutter.Structs.ActorClass.ActorClass'.@/destroy/@() or the t'GI.GObject.Structs.ObjectClass.ObjectClass'.@/dispose/@()
-- implementation, but it is guaranteed to be called before the
-- t'GI.GObject.Structs.ObjectClass.ObjectClass'.@/finalize/@() implementation.
-- 
-- /Since: 1.0/
actorUnmap ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorUnmap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorUnmap a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_unmap Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorUnmapMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorUnmapMethodInfo a signature where
    overloadedMethod = actorUnmap

instance O.OverloadedMethodInfo ActorUnmapMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorUnmap",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorUnmap"
        })


#endif

-- method Actor::unparent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_unparent" clutter_actor_unparent :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorUnparent ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorRemoveChild' instead."] #-}
-- | Removes the parent of /@self@/.
-- 
-- This will cause the parent of /@self@/ to release the reference
-- acquired when calling 'GI.Clutter.Objects.Actor.actorSetParent', so if you
-- want to keep /@self@/ you will have to acquire a reference of
-- your own, through 'GI.GObject.Objects.Object.objectRef'.
-- 
-- This function should only be called by legacy t'GI.Clutter.Objects.Actor.Actor's
-- implementing the t'GI.Clutter.Interfaces.Container.Container' interface.
-- 
-- /Since: 0.2/
actorUnparent ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorUnparent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorUnparent a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_unparent Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorUnparentMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorUnparentMethodInfo a signature where
    overloadedMethod = actorUnparent

instance O.OverloadedMethodInfo ActorUnparentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorUnparent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorUnparent"
        })


#endif

-- method Actor::unrealize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_unrealize" clutter_actor_unrealize :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

{-# DEPRECATED actorUnrealize ["(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 'GI.Clutter.Objects.Actor.actorUnrealize' in a dispose
-- implementation, then don\'t, just chain up to ClutterActor\'s
-- dispose.
-- 
-- If you were using 'GI.Clutter.Objects.Actor.actorUnrealize' to implement
-- unrealizing children of your container, then don\'t, ClutterActor
-- will already take care of that.
actorUnrealize ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.Actor.Actor'
    -> m ()
actorUnrealize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m ()
actorUnrealize a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Actor -> IO ()
clutter_actor_unrealize Ptr Actor
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorUnrealizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorUnrealizeMethodInfo a signature where
    overloadedMethod = actorUnrealize

instance O.OverloadedMethodInfo ActorUnrealizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorUnrealize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorUnrealize"
        })


#endif

-- method Actor::unset_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ActorFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the flags to unset" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_actor_unset_flags" clutter_actor_unset_flags :: 
    Ptr Actor ->                            -- self : TInterface (Name {namespace = "Clutter", name = "Actor"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "ActorFlags"})
    IO ()

-- | Unsets /@flags@/ on /@self@/
-- 
-- This function will emit notifications for the changed properties
-- 
-- /Since: 1.0/
actorUnsetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsActor a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Actor.Actor'
    -> [Clutter.Flags.ActorFlags]
    -- ^ /@flags@/: the flags to unset
    -> m ()
actorUnsetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> [ActorFlags] -> m ()
actorUnsetFlags a
self [ActorFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
self' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let flags' :: CUInt
flags' = [ActorFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ActorFlags]
flags
    Ptr Actor -> CUInt -> IO ()
clutter_actor_unset_flags Ptr Actor
self' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActorUnsetFlagsMethodInfo
instance (signature ~ ([Clutter.Flags.ActorFlags] -> m ()), MonadIO m, IsActor a) => O.OverloadedMethod ActorUnsetFlagsMethodInfo a signature where
    overloadedMethod = actorUnsetFlags

instance O.OverloadedMethodInfo ActorUnsetFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Actor.actorUnsetFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-Actor.html#v:actorUnsetFlags"
        })


#endif