{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Clutter.Objects.Rectangle.Rectangle' structure contains only private data
-- and should be accessed using the provided API
-- 
-- /Since: 0.2/

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

module GI.Clutter.Objects.Rectangle
    ( 

-- * Exported types
    Rectangle(..)                           ,
    IsRectangle                             ,
    toRectangle                             ,


 -- * 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"), [getBorderColor]("GI.Clutter.Objects.Rectangle#g:method:getBorderColor"), [getBorderWidth]("GI.Clutter.Objects.Rectangle#g:method:getBorderWidth"), [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"), [getColor]("GI.Clutter.Objects.Rectangle#g:method:getColor"), [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"), [setBorderColor]("GI.Clutter.Objects.Rectangle#g:method:setBorderColor"), [setBorderWidth]("GI.Clutter.Objects.Rectangle#g:method:setBorderWidth"), [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"), [setColor]("GI.Clutter.Objects.Rectangle#g:method:setColor"), [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)
    ResolveRectangleMethod                  ,
#endif

-- ** getBorderColor #method:getBorderColor#

#if defined(ENABLE_OVERLOADING)
    RectangleGetBorderColorMethodInfo       ,
#endif
    rectangleGetBorderColor                 ,


-- ** getBorderWidth #method:getBorderWidth#

#if defined(ENABLE_OVERLOADING)
    RectangleGetBorderWidthMethodInfo       ,
#endif
    rectangleGetBorderWidth                 ,


-- ** getColor #method:getColor#

#if defined(ENABLE_OVERLOADING)
    RectangleGetColorMethodInfo             ,
#endif
    rectangleGetColor                       ,


-- ** new #method:new#

    rectangleNew                            ,


-- ** newWithColor #method:newWithColor#

    rectangleNewWithColor                   ,


-- ** setBorderColor #method:setBorderColor#

#if defined(ENABLE_OVERLOADING)
    RectangleSetBorderColorMethodInfo       ,
#endif
    rectangleSetBorderColor                 ,


-- ** setBorderWidth #method:setBorderWidth#

#if defined(ENABLE_OVERLOADING)
    RectangleSetBorderWidthMethodInfo       ,
#endif
    rectangleSetBorderWidth                 ,


-- ** setColor #method:setColor#

#if defined(ENABLE_OVERLOADING)
    RectangleSetColorMethodInfo             ,
#endif
    rectangleSetColor                       ,




 -- * Properties


-- ** borderColor #attr:borderColor#
-- | The color of the border of the rectangle.
-- 
-- /Since: 0.2/

#if defined(ENABLE_OVERLOADING)
    RectangleBorderColorPropertyInfo        ,
#endif
    constructRectangleBorderColor           ,
    getRectangleBorderColor                 ,
#if defined(ENABLE_OVERLOADING)
    rectangleBorderColor                    ,
#endif
    setRectangleBorderColor                 ,


-- ** borderWidth #attr:borderWidth#
-- | The width of the border of the rectangle, in pixels.
-- 
-- /Since: 0.2/

#if defined(ENABLE_OVERLOADING)
    RectangleBorderWidthPropertyInfo        ,
#endif
    constructRectangleBorderWidth           ,
    getRectangleBorderWidth                 ,
#if defined(ENABLE_OVERLOADING)
    rectangleBorderWidth                    ,
#endif
    setRectangleBorderWidth                 ,


-- ** color #attr:color#
-- | The color of the rectangle.

#if defined(ENABLE_OVERLOADING)
    RectangleColorPropertyInfo              ,
#endif
    constructRectangleColor                 ,
    getRectangleColor                       ,
#if defined(ENABLE_OVERLOADING)
    rectangleColor                          ,
#endif
    setRectangleColor                       ,


-- ** hasBorder #attr:hasBorder#
-- | Whether the t'GI.Clutter.Objects.Rectangle.Rectangle' should be displayed with a border.
-- 
-- /Since: 0.2/

#if defined(ENABLE_OVERLOADING)
    RectangleHasBorderPropertyInfo          ,
#endif
    constructRectangleHasBorder             ,
    getRectangleHasBorder                   ,
#if defined(ENABLE_OVERLOADING)
    rectangleHasBorder                      ,
#endif
    setRectangleHasBorder                   ,




    ) 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.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.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 GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
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.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "clutter_rectangle_get_type"
    c_clutter_rectangle_get_type :: IO B.Types.GType

instance B.Types.TypedObject Rectangle where
    glibType :: IO GType
glibType = IO GType
c_clutter_rectangle_get_type

instance B.Types.GObject Rectangle

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

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

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

-- | Convert 'Rectangle' 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 Rectangle) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_rectangle_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Rectangle -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Rectangle
P.Nothing = Ptr GValue -> Ptr Rectangle -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Rectangle
forall a. Ptr a
FP.nullPtr :: FP.Ptr Rectangle)
    gvalueSet_ Ptr GValue
gv (P.Just Rectangle
obj) = Rectangle -> (Ptr Rectangle -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Rectangle
obj (Ptr GValue -> Ptr Rectangle -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Rectangle)
gvalueGet_ Ptr GValue
gv = do
        Ptr Rectangle
ptr <- Ptr GValue -> IO (Ptr Rectangle)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Rectangle)
        if Ptr Rectangle
ptr Ptr Rectangle -> Ptr Rectangle -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Rectangle
forall a. Ptr a
FP.nullPtr
        then Rectangle -> Maybe Rectangle
forall a. a -> Maybe a
P.Just (Rectangle -> Maybe Rectangle)
-> IO Rectangle -> IO (Maybe Rectangle)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Rectangle -> Rectangle
Rectangle Ptr Rectangle
ptr
        else Maybe Rectangle -> IO (Maybe Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Rectangle
forall a. Maybe a
P.Nothing
        
    

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

instance (info ~ ResolveRectangleMethod t Rectangle, O.OverloadedMethod info Rectangle p) => OL.IsLabel t (Rectangle -> 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 ~ ResolveRectangleMethod t Rectangle, O.OverloadedMethod info Rectangle p, R.HasField t Rectangle p) => R.HasField t Rectangle p where
    getField = O.overloadedMethod @info

#endif

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

#endif

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

-- | Get the value of the “@border-color@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' rectangle #borderColor
-- @
getRectangleBorderColor :: (MonadIO m, IsRectangle o) => o -> m (Maybe Clutter.Color.Color)
getRectangleBorderColor :: forall (m :: * -> *) o.
(MonadIO m, IsRectangle o) =>
o -> m (Maybe Color)
getRectangleBorderColor o
obj = IO (Maybe Color) -> m (Maybe Color)
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
"border-color" ManagedPtr Color -> Color
Clutter.Color.Color

-- | Set the value of the “@border-color@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' rectangle [ #borderColor 'Data.GI.Base.Attributes.:=' value ]
-- @
setRectangleBorderColor :: (MonadIO m, IsRectangle o) => o -> Clutter.Color.Color -> m ()
setRectangleBorderColor :: forall (m :: * -> *) o.
(MonadIO m, IsRectangle o) =>
o -> Color -> m ()
setRectangleBorderColor o
obj Color
val = IO () -> m ()
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
"border-color" (Color -> Maybe Color
forall a. a -> Maybe a
Just Color
val)

-- | Construct a `GValueConstruct` with valid value for the “@border-color@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructRectangleBorderColor :: (IsRectangle o, MIO.MonadIO m) => Clutter.Color.Color -> m (GValueConstruct o)
constructRectangleBorderColor :: forall o (m :: * -> *).
(IsRectangle o, MonadIO m) =>
Color -> m (GValueConstruct o)
constructRectangleBorderColor Color
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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
"border-color" (Color -> Maybe Color
forall a. a -> Maybe a
P.Just Color
val)

#if defined(ENABLE_OVERLOADING)
data RectangleBorderColorPropertyInfo
instance AttrInfo RectangleBorderColorPropertyInfo where
    type AttrAllowedOps RectangleBorderColorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint RectangleBorderColorPropertyInfo = IsRectangle
    type AttrSetTypeConstraint RectangleBorderColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferTypeConstraint RectangleBorderColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferType RectangleBorderColorPropertyInfo = Clutter.Color.Color
    type AttrGetType RectangleBorderColorPropertyInfo = (Maybe Clutter.Color.Color)
    type AttrLabel RectangleBorderColorPropertyInfo = "border-color"
    type AttrOrigin RectangleBorderColorPropertyInfo = Rectangle
    attrGet = getRectangleBorderColor
    attrSet = setRectangleBorderColor
    attrTransfer _ v = do
        return v
    attrConstruct = constructRectangleBorderColor
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.borderColor"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#g:attr:borderColor"
        })
#endif

-- VVV Prop "border-width"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@border-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' rectangle #borderWidth
-- @
getRectangleBorderWidth :: (MonadIO m, IsRectangle o) => o -> m Word32
getRectangleBorderWidth :: forall (m :: * -> *) o. (MonadIO m, IsRectangle o) => o -> m Word32
getRectangleBorderWidth o
obj = IO Word32 -> m Word32
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
"border-width"

-- | Set the value of the “@border-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' rectangle [ #borderWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setRectangleBorderWidth :: (MonadIO m, IsRectangle o) => o -> Word32 -> m ()
setRectangleBorderWidth :: forall (m :: * -> *) o.
(MonadIO m, IsRectangle o) =>
o -> Word32 -> m ()
setRectangleBorderWidth o
obj Word32
val = IO () -> m ()
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
"border-width" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@border-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructRectangleBorderWidth :: (IsRectangle o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructRectangleBorderWidth :: forall o (m :: * -> *).
(IsRectangle o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructRectangleBorderWidth Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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
"border-width" Word32
val

#if defined(ENABLE_OVERLOADING)
data RectangleBorderWidthPropertyInfo
instance AttrInfo RectangleBorderWidthPropertyInfo where
    type AttrAllowedOps RectangleBorderWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint RectangleBorderWidthPropertyInfo = IsRectangle
    type AttrSetTypeConstraint RectangleBorderWidthPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint RectangleBorderWidthPropertyInfo = (~) Word32
    type AttrTransferType RectangleBorderWidthPropertyInfo = Word32
    type AttrGetType RectangleBorderWidthPropertyInfo = Word32
    type AttrLabel RectangleBorderWidthPropertyInfo = "border-width"
    type AttrOrigin RectangleBorderWidthPropertyInfo = Rectangle
    attrGet = getRectangleBorderWidth
    attrSet = setRectangleBorderWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructRectangleBorderWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.borderWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#g:attr:borderWidth"
        })
#endif

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

-- | Get the value of the “@color@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' rectangle #color
-- @
getRectangleColor :: (MonadIO m, IsRectangle o) => o -> m (Maybe Clutter.Color.Color)
getRectangleColor :: forall (m :: * -> *) o.
(MonadIO m, IsRectangle o) =>
o -> m (Maybe Color)
getRectangleColor o
obj = IO (Maybe Color) -> m (Maybe Color)
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
"color" ManagedPtr Color -> Color
Clutter.Color.Color

-- | Set the value of the “@color@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' rectangle [ #color 'Data.GI.Base.Attributes.:=' value ]
-- @
setRectangleColor :: (MonadIO m, IsRectangle o) => o -> Clutter.Color.Color -> m ()
setRectangleColor :: forall (m :: * -> *) o.
(MonadIO m, IsRectangle o) =>
o -> Color -> m ()
setRectangleColor o
obj Color
val = IO () -> m ()
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
"color" (Color -> Maybe Color
forall a. a -> Maybe a
Just Color
val)

-- | Construct a `GValueConstruct` with valid value for the “@color@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructRectangleColor :: (IsRectangle o, MIO.MonadIO m) => Clutter.Color.Color -> m (GValueConstruct o)
constructRectangleColor :: forall o (m :: * -> *).
(IsRectangle o, MonadIO m) =>
Color -> m (GValueConstruct o)
constructRectangleColor Color
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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
"color" (Color -> Maybe Color
forall a. a -> Maybe a
P.Just Color
val)

#if defined(ENABLE_OVERLOADING)
data RectangleColorPropertyInfo
instance AttrInfo RectangleColorPropertyInfo where
    type AttrAllowedOps RectangleColorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint RectangleColorPropertyInfo = IsRectangle
    type AttrSetTypeConstraint RectangleColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferTypeConstraint RectangleColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferType RectangleColorPropertyInfo = Clutter.Color.Color
    type AttrGetType RectangleColorPropertyInfo = (Maybe Clutter.Color.Color)
    type AttrLabel RectangleColorPropertyInfo = "color"
    type AttrOrigin RectangleColorPropertyInfo = Rectangle
    attrGet = getRectangleColor
    attrSet = setRectangleColor
    attrTransfer _ v = do
        return v
    attrConstruct = constructRectangleColor
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.color"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#g:attr:color"
        })
#endif

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

-- | Get the value of the “@has-border@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' rectangle #hasBorder
-- @
getRectangleHasBorder :: (MonadIO m, IsRectangle o) => o -> m Bool
getRectangleHasBorder :: forall (m :: * -> *) o. (MonadIO m, IsRectangle o) => o -> m Bool
getRectangleHasBorder o
obj = IO Bool -> m Bool
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-border"

-- | Set the value of the “@has-border@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' rectangle [ #hasBorder 'Data.GI.Base.Attributes.:=' value ]
-- @
setRectangleHasBorder :: (MonadIO m, IsRectangle o) => o -> Bool -> m ()
setRectangleHasBorder :: forall (m :: * -> *) o.
(MonadIO m, IsRectangle o) =>
o -> Bool -> m ()
setRectangleHasBorder o
obj Bool
val = IO () -> m ()
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
"has-border" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@has-border@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructRectangleHasBorder :: (IsRectangle o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructRectangleHasBorder :: forall o (m :: * -> *).
(IsRectangle o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructRectangleHasBorder Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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
"has-border" Bool
val

#if defined(ENABLE_OVERLOADING)
data RectangleHasBorderPropertyInfo
instance AttrInfo RectangleHasBorderPropertyInfo where
    type AttrAllowedOps RectangleHasBorderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint RectangleHasBorderPropertyInfo = IsRectangle
    type AttrSetTypeConstraint RectangleHasBorderPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint RectangleHasBorderPropertyInfo = (~) Bool
    type AttrTransferType RectangleHasBorderPropertyInfo = Bool
    type AttrGetType RectangleHasBorderPropertyInfo = Bool
    type AttrLabel RectangleHasBorderPropertyInfo = "has-border"
    type AttrOrigin RectangleHasBorderPropertyInfo = Rectangle
    attrGet = getRectangleHasBorder
    attrSet = setRectangleHasBorder
    attrTransfer _ v = do
        return v
    attrConstruct = constructRectangleHasBorder
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.hasBorder"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#g:attr:hasBorder"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Rectangle
type instance O.AttributeList Rectangle = RectangleAttributeList
type RectangleAttributeList = ('[ '("actions", Clutter.Actor.ActorActionsPropertyInfo), '("allocation", Clutter.Actor.ActorAllocationPropertyInfo), '("anchorGravity", Clutter.Actor.ActorAnchorGravityPropertyInfo), '("anchorX", Clutter.Actor.ActorAnchorXPropertyInfo), '("anchorY", Clutter.Actor.ActorAnchorYPropertyInfo), '("backgroundColor", Clutter.Actor.ActorBackgroundColorPropertyInfo), '("backgroundColorSet", Clutter.Actor.ActorBackgroundColorSetPropertyInfo), '("borderColor", RectangleBorderColorPropertyInfo), '("borderWidth", RectangleBorderWidthPropertyInfo), '("childTransform", Clutter.Actor.ActorChildTransformPropertyInfo), '("childTransformSet", Clutter.Actor.ActorChildTransformSetPropertyInfo), '("clip", Clutter.Actor.ActorClipPropertyInfo), '("clipRect", Clutter.Actor.ActorClipRectPropertyInfo), '("clipToAllocation", Clutter.Actor.ActorClipToAllocationPropertyInfo), '("color", RectangleColorPropertyInfo), '("constraints", Clutter.Actor.ActorConstraintsPropertyInfo), '("content", Clutter.Actor.ActorContentPropertyInfo), '("contentBox", Clutter.Actor.ActorContentBoxPropertyInfo), '("contentGravity", Clutter.Actor.ActorContentGravityPropertyInfo), '("contentRepeat", Clutter.Actor.ActorContentRepeatPropertyInfo), '("depth", Clutter.Actor.ActorDepthPropertyInfo), '("effect", Clutter.Actor.ActorEffectPropertyInfo), '("firstChild", Clutter.Actor.ActorFirstChildPropertyInfo), '("fixedPositionSet", Clutter.Actor.ActorFixedPositionSetPropertyInfo), '("fixedX", Clutter.Actor.ActorFixedXPropertyInfo), '("fixedY", Clutter.Actor.ActorFixedYPropertyInfo), '("hasBorder", RectangleHasBorderPropertyInfo), '("hasClip", Clutter.Actor.ActorHasClipPropertyInfo), '("hasPointer", Clutter.Actor.ActorHasPointerPropertyInfo), '("height", Clutter.Actor.ActorHeightPropertyInfo), '("lastChild", Clutter.Actor.ActorLastChildPropertyInfo), '("layoutManager", Clutter.Actor.ActorLayoutManagerPropertyInfo), '("magnificationFilter", Clutter.Actor.ActorMagnificationFilterPropertyInfo), '("mapped", Clutter.Actor.ActorMappedPropertyInfo), '("marginBottom", Clutter.Actor.ActorMarginBottomPropertyInfo), '("marginLeft", Clutter.Actor.ActorMarginLeftPropertyInfo), '("marginRight", Clutter.Actor.ActorMarginRightPropertyInfo), '("marginTop", Clutter.Actor.ActorMarginTopPropertyInfo), '("minHeight", Clutter.Actor.ActorMinHeightPropertyInfo), '("minHeightSet", Clutter.Actor.ActorMinHeightSetPropertyInfo), '("minWidth", Clutter.Actor.ActorMinWidthPropertyInfo), '("minWidthSet", Clutter.Actor.ActorMinWidthSetPropertyInfo), '("minificationFilter", Clutter.Actor.ActorMinificationFilterPropertyInfo), '("name", Clutter.Actor.ActorNamePropertyInfo), '("naturalHeight", Clutter.Actor.ActorNaturalHeightPropertyInfo), '("naturalHeightSet", Clutter.Actor.ActorNaturalHeightSetPropertyInfo), '("naturalWidth", Clutter.Actor.ActorNaturalWidthPropertyInfo), '("naturalWidthSet", Clutter.Actor.ActorNaturalWidthSetPropertyInfo), '("offscreenRedirect", Clutter.Actor.ActorOffscreenRedirectPropertyInfo), '("opacity", Clutter.Actor.ActorOpacityPropertyInfo), '("pivotPoint", Clutter.Actor.ActorPivotPointPropertyInfo), '("pivotPointZ", Clutter.Actor.ActorPivotPointZPropertyInfo), '("position", Clutter.Actor.ActorPositionPropertyInfo), '("reactive", Clutter.Actor.ActorReactivePropertyInfo), '("realized", Clutter.Actor.ActorRealizedPropertyInfo), '("requestMode", Clutter.Actor.ActorRequestModePropertyInfo), '("rotationAngleX", Clutter.Actor.ActorRotationAngleXPropertyInfo), '("rotationAngleY", Clutter.Actor.ActorRotationAngleYPropertyInfo), '("rotationAngleZ", Clutter.Actor.ActorRotationAngleZPropertyInfo), '("rotationCenterX", Clutter.Actor.ActorRotationCenterXPropertyInfo), '("rotationCenterY", Clutter.Actor.ActorRotationCenterYPropertyInfo), '("rotationCenterZ", Clutter.Actor.ActorRotationCenterZPropertyInfo), '("rotationCenterZGravity", Clutter.Actor.ActorRotationCenterZGravityPropertyInfo), '("scaleCenterX", Clutter.Actor.ActorScaleCenterXPropertyInfo), '("scaleCenterY", Clutter.Actor.ActorScaleCenterYPropertyInfo), '("scaleGravity", Clutter.Actor.ActorScaleGravityPropertyInfo), '("scaleX", Clutter.Actor.ActorScaleXPropertyInfo), '("scaleY", Clutter.Actor.ActorScaleYPropertyInfo), '("scaleZ", Clutter.Actor.ActorScaleZPropertyInfo), '("showOnSetParent", Clutter.Actor.ActorShowOnSetParentPropertyInfo), '("size", Clutter.Actor.ActorSizePropertyInfo), '("textDirection", Clutter.Actor.ActorTextDirectionPropertyInfo), '("transform", Clutter.Actor.ActorTransformPropertyInfo), '("transformSet", Clutter.Actor.ActorTransformSetPropertyInfo), '("translationX", Clutter.Actor.ActorTranslationXPropertyInfo), '("translationY", Clutter.Actor.ActorTranslationYPropertyInfo), '("translationZ", Clutter.Actor.ActorTranslationZPropertyInfo), '("visible", Clutter.Actor.ActorVisiblePropertyInfo), '("width", Clutter.Actor.ActorWidthPropertyInfo), '("x", Clutter.Actor.ActorXPropertyInfo), '("xAlign", Clutter.Actor.ActorXAlignPropertyInfo), '("xExpand", Clutter.Actor.ActorXExpandPropertyInfo), '("y", Clutter.Actor.ActorYPropertyInfo), '("yAlign", Clutter.Actor.ActorYAlignPropertyInfo), '("yExpand", Clutter.Actor.ActorYExpandPropertyInfo), '("zPosition", Clutter.Actor.ActorZPositionPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
rectangleBorderColor :: AttrLabelProxy "borderColor"
rectangleBorderColor = AttrLabelProxy

rectangleBorderWidth :: AttrLabelProxy "borderWidth"
rectangleBorderWidth = AttrLabelProxy

rectangleColor :: AttrLabelProxy "color"
rectangleColor = AttrLabelProxy

rectangleHasBorder :: AttrLabelProxy "hasBorder"
rectangleHasBorder = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Rectangle = RectangleSignalList
type RectangleSignalList = ('[ '("actorAdded", Clutter.Container.ContainerActorAddedSignalInfo), '("actorRemoved", Clutter.Container.ContainerActorRemovedSignalInfo), '("allocationChanged", Clutter.Actor.ActorAllocationChangedSignalInfo), '("buttonPressEvent", Clutter.Actor.ActorButtonPressEventSignalInfo), '("buttonReleaseEvent", Clutter.Actor.ActorButtonReleaseEventSignalInfo), '("capturedEvent", Clutter.Actor.ActorCapturedEventSignalInfo), '("childNotify", Clutter.Container.ContainerChildNotifySignalInfo), '("destroy", Clutter.Actor.ActorDestroySignalInfo), '("enterEvent", Clutter.Actor.ActorEnterEventSignalInfo), '("event", Clutter.Actor.ActorEventSignalInfo), '("hide", Clutter.Actor.ActorHideSignalInfo), '("keyFocusIn", Clutter.Actor.ActorKeyFocusInSignalInfo), '("keyFocusOut", Clutter.Actor.ActorKeyFocusOutSignalInfo), '("keyPressEvent", Clutter.Actor.ActorKeyPressEventSignalInfo), '("keyReleaseEvent", Clutter.Actor.ActorKeyReleaseEventSignalInfo), '("leaveEvent", Clutter.Actor.ActorLeaveEventSignalInfo), '("motionEvent", Clutter.Actor.ActorMotionEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paint", Clutter.Actor.ActorPaintSignalInfo), '("parentSet", Clutter.Actor.ActorParentSetSignalInfo), '("pick", Clutter.Actor.ActorPickSignalInfo), '("queueRedraw", Clutter.Actor.ActorQueueRedrawSignalInfo), '("queueRelayout", Clutter.Actor.ActorQueueRelayoutSignalInfo), '("realize", Clutter.Actor.ActorRealizeSignalInfo), '("scrollEvent", Clutter.Actor.ActorScrollEventSignalInfo), '("show", Clutter.Actor.ActorShowSignalInfo), '("touchEvent", Clutter.Actor.ActorTouchEventSignalInfo), '("transitionStopped", Clutter.Actor.ActorTransitionStoppedSignalInfo), '("transitionsCompleted", Clutter.Actor.ActorTransitionsCompletedSignalInfo), '("unrealize", Clutter.Actor.ActorUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

-- method Rectangle::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "Rectangle" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_rectangle_new" clutter_rectangle_new :: 
    IO (Ptr Rectangle)

{-# DEPRECATED rectangleNew ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorNew' instead"] #-}
-- | Creates a new t'GI.Clutter.Objects.Actor.Actor' with a rectangular shape.
rectangleNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Rectangle
    -- ^ __Returns:__ a new t'GI.Clutter.Objects.Rectangle.Rectangle'
rectangleNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Rectangle
rectangleNew  = IO Rectangle -> m Rectangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
forall a b. (a -> b) -> a -> b
$ do
    Ptr Rectangle
result <- IO (Ptr Rectangle)
clutter_rectangle_new
    Text -> Ptr Rectangle -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"rectangleNew" Ptr Rectangle
result
    Rectangle
result' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Rectangle -> Rectangle
Rectangle) Ptr Rectangle
result
    Rectangle -> IO Rectangle
forall (m :: * -> *) a. Monad m => a -> m a
return Rectangle
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Rectangle::new_with_color
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterColor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "Rectangle" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_rectangle_new_with_color" clutter_rectangle_new_with_color :: 
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO (Ptr Rectangle)

{-# DEPRECATED rectangleNewWithColor ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorNew' and","  'GI.Clutter.Objects.Actor.actorSetBackgroundColor' instead"] #-}
-- | Creates a new t'GI.Clutter.Objects.Actor.Actor' with a rectangular shape
-- and of the given /@color@/.
rectangleNewWithColor ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Clutter.Color.Color
    -- ^ /@color@/: a t'GI.Clutter.Structs.Color.Color'
    -> m Rectangle
    -- ^ __Returns:__ a new t'GI.Clutter.Objects.Rectangle.Rectangle'
rectangleNewWithColor :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> m Rectangle
rectangleNewWithColor Color
color = IO Rectangle -> m Rectangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
forall a b. (a -> b) -> a -> b
$ do
    Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
    Ptr Rectangle
result <- Ptr Color -> IO (Ptr Rectangle)
clutter_rectangle_new_with_color Ptr Color
color'
    Text -> Ptr Rectangle -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"rectangleNewWithColor" Ptr Rectangle
result
    Rectangle
result' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Rectangle -> Rectangle
Rectangle) Ptr Rectangle
result
    Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
    Rectangle -> IO Rectangle
forall (m :: * -> *) a. Monad m => a -> m a
return Rectangle
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Rectangle::get_border_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rectangle"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterRectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_rectangle_get_border_color" clutter_rectangle_get_border_color :: 
    Ptr Rectangle ->                        -- rectangle : TInterface (Name {namespace = "Clutter", name = "Rectangle"})
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO ()

{-# DEPRECATED rectangleGetBorderColor ["(Since version 1.10)","Use t'GI.Clutter.Objects.Actor.Actor' and a t'GI.Clutter.Objects.Canvas.Canvas' to draw","  the border with Cairo"] #-}
-- | Gets the color of the border used by /@rectangle@/ and places
-- it into /@color@/.
-- 
-- /Since: 0.2/
rectangleGetBorderColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsRectangle a) =>
    a
    -- ^ /@rectangle@/: a t'GI.Clutter.Objects.Rectangle.Rectangle'
    -> m (Clutter.Color.Color)
rectangleGetBorderColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRectangle a) =>
a -> m Color
rectangleGetBorderColor a
rectangle = IO Color -> m Color
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 Rectangle
rectangle' <- a -> IO (Ptr Rectangle)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
rectangle
    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 Rectangle -> Ptr Color -> IO ()
clutter_rectangle_get_border_color Ptr Rectangle
rectangle' 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
rectangle
    Color -> IO Color
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'

#if defined(ENABLE_OVERLOADING)
data RectangleGetBorderColorMethodInfo
instance (signature ~ (m (Clutter.Color.Color)), MonadIO m, IsRectangle a) => O.OverloadedMethod RectangleGetBorderColorMethodInfo a signature where
    overloadedMethod = rectangleGetBorderColor

instance O.OverloadedMethodInfo RectangleGetBorderColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.rectangleGetBorderColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#v:rectangleGetBorderColor"
        })


#endif

-- method Rectangle::get_border_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rectangle"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterRectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_rectangle_get_border_width" clutter_rectangle_get_border_width :: 
    Ptr Rectangle ->                        -- rectangle : TInterface (Name {namespace = "Clutter", name = "Rectangle"})
    IO Word32

{-# DEPRECATED rectangleGetBorderWidth ["(Since version 1.10)","Use t'GI.Clutter.Objects.Actor.Actor' and a t'GI.Clutter.Objects.Canvas.Canvas' content","  to draw the border using Cairo"] #-}
-- | Gets the width (in pixels) of the border used by /@rectangle@/
-- 
-- /Since: 0.2/
rectangleGetBorderWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsRectangle a) =>
    a
    -- ^ /@rectangle@/: a t'GI.Clutter.Objects.Rectangle.Rectangle'
    -> m Word32
    -- ^ __Returns:__ the border\'s width
rectangleGetBorderWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRectangle a) =>
a -> m Word32
rectangleGetBorderWidth a
rectangle = IO Word32 -> m Word32
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 Rectangle
rectangle' <- a -> IO (Ptr Rectangle)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
rectangle
    Word32
result <- Ptr Rectangle -> IO Word32
clutter_rectangle_get_border_width Ptr Rectangle
rectangle'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
rectangle
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data RectangleGetBorderWidthMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsRectangle a) => O.OverloadedMethod RectangleGetBorderWidthMethodInfo a signature where
    overloadedMethod = rectangleGetBorderWidth

instance O.OverloadedMethodInfo RectangleGetBorderWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.rectangleGetBorderWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#v:rectangleGetBorderWidth"
        })


#endif

-- method Rectangle::get_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rectangle"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterRectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_rectangle_get_color" clutter_rectangle_get_color :: 
    Ptr Rectangle ->                        -- rectangle : TInterface (Name {namespace = "Clutter", name = "Rectangle"})
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO ()

{-# DEPRECATED rectangleGetColor ["(Since version 1.10)","Use t'GI.Clutter.Objects.Actor.Actor' and 'GI.Clutter.Objects.Actor.actorGetBackgroundColor'","  instead"] #-}
-- | Retrieves the color of /@rectangle@/.
rectangleGetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsRectangle a) =>
    a
    -- ^ /@rectangle@/: a t'GI.Clutter.Objects.Rectangle.Rectangle'
    -> m (Clutter.Color.Color)
rectangleGetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRectangle a) =>
a -> m Color
rectangleGetColor a
rectangle = IO Color -> m Color
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 Rectangle
rectangle' <- a -> IO (Ptr Rectangle)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
rectangle
    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 Rectangle -> Ptr Color -> IO ()
clutter_rectangle_get_color Ptr Rectangle
rectangle' 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
rectangle
    Color -> IO Color
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'

#if defined(ENABLE_OVERLOADING)
data RectangleGetColorMethodInfo
instance (signature ~ (m (Clutter.Color.Color)), MonadIO m, IsRectangle a) => O.OverloadedMethod RectangleGetColorMethodInfo a signature where
    overloadedMethod = rectangleGetColor

instance O.OverloadedMethodInfo RectangleGetColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.rectangleGetColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#v:rectangleGetColor"
        })


#endif

-- method Rectangle::set_border_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rectangle"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterRectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the color of the border"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_rectangle_set_border_color" clutter_rectangle_set_border_color :: 
    Ptr Rectangle ->                        -- rectangle : TInterface (Name {namespace = "Clutter", name = "Rectangle"})
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO ()

{-# DEPRECATED rectangleSetBorderColor ["(Since version 1.10)","Use t'GI.Clutter.Objects.Actor.Actor' and a t'GI.Clutter.Objects.Canvas.Canvas' to draw","  the border with Cairo"] #-}
-- | Sets the color of the border used by /@rectangle@/ using /@color@/
rectangleSetBorderColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsRectangle a) =>
    a
    -- ^ /@rectangle@/: a t'GI.Clutter.Objects.Rectangle.Rectangle'
    -> Clutter.Color.Color
    -- ^ /@color@/: the color of the border
    -> m ()
rectangleSetBorderColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRectangle a) =>
a -> Color -> m ()
rectangleSetBorderColor a
rectangle Color
color = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Rectangle
rectangle' <- a -> IO (Ptr Rectangle)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
rectangle
    Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
    Ptr Rectangle -> Ptr Color -> IO ()
clutter_rectangle_set_border_color Ptr Rectangle
rectangle' Ptr Color
color'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
rectangle
    Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RectangleSetBorderColorMethodInfo
instance (signature ~ (Clutter.Color.Color -> m ()), MonadIO m, IsRectangle a) => O.OverloadedMethod RectangleSetBorderColorMethodInfo a signature where
    overloadedMethod = rectangleSetBorderColor

instance O.OverloadedMethodInfo RectangleSetBorderColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.rectangleSetBorderColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#v:rectangleSetBorderColor"
        })


#endif

-- method Rectangle::set_border_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rectangle"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterRectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the width of the border"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_rectangle_set_border_width" clutter_rectangle_set_border_width :: 
    Ptr Rectangle ->                        -- rectangle : TInterface (Name {namespace = "Clutter", name = "Rectangle"})
    Word32 ->                               -- width : TBasicType TUInt
    IO ()

{-# DEPRECATED rectangleSetBorderWidth ["(Since version 1.10)","Use t'GI.Clutter.Objects.Actor.Actor' and a t'GI.Clutter.Objects.Canvas.Canvas' content","  to draw the border using Cairo"] #-}
-- | Sets the width (in pixel) of the border used by /@rectangle@/.
-- A /@width@/ of 0 will unset the border.
-- 
-- /Since: 0.2/
rectangleSetBorderWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsRectangle a) =>
    a
    -- ^ /@rectangle@/: a t'GI.Clutter.Objects.Rectangle.Rectangle'
    -> Word32
    -- ^ /@width@/: the width of the border
    -> m ()
rectangleSetBorderWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRectangle a) =>
a -> Word32 -> m ()
rectangleSetBorderWidth a
rectangle Word32
width = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Rectangle
rectangle' <- a -> IO (Ptr Rectangle)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
rectangle
    Ptr Rectangle -> Word32 -> IO ()
clutter_rectangle_set_border_width Ptr Rectangle
rectangle' Word32
width
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
rectangle
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RectangleSetBorderWidthMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsRectangle a) => O.OverloadedMethod RectangleSetBorderWidthMethodInfo a signature where
    overloadedMethod = rectangleSetBorderWidth

instance O.OverloadedMethodInfo RectangleSetBorderWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.rectangleSetBorderWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#v:rectangleSetBorderWidth"
        })


#endif

-- method Rectangle::set_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "rectangle"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterRectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterColor" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_rectangle_set_color" clutter_rectangle_set_color :: 
    Ptr Rectangle ->                        -- rectangle : TInterface (Name {namespace = "Clutter", name = "Rectangle"})
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO ()

{-# DEPRECATED rectangleSetColor ["(Since version 1.10)","Use t'GI.Clutter.Objects.Actor.Actor' and 'GI.Clutter.Objects.Actor.actorSetBackgroundColor'","  instead"] #-}
-- | Sets the color of /@rectangle@/.
rectangleSetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsRectangle a) =>
    a
    -- ^ /@rectangle@/: a t'GI.Clutter.Objects.Rectangle.Rectangle'
    -> Clutter.Color.Color
    -- ^ /@color@/: a t'GI.Clutter.Structs.Color.Color'
    -> m ()
rectangleSetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRectangle a) =>
a -> Color -> m ()
rectangleSetColor a
rectangle Color
color = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Rectangle
rectangle' <- a -> IO (Ptr Rectangle)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
rectangle
    Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
    Ptr Rectangle -> Ptr Color -> IO ()
clutter_rectangle_set_color Ptr Rectangle
rectangle' Ptr Color
color'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
rectangle
    Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RectangleSetColorMethodInfo
instance (signature ~ (Clutter.Color.Color -> m ()), MonadIO m, IsRectangle a) => O.OverloadedMethod RectangleSetColorMethodInfo a signature where
    overloadedMethod = rectangleSetColor

instance O.OverloadedMethodInfo RectangleSetColorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Rectangle.rectangleSetColor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Rectangle.html#v:rectangleSetColor"
        })


#endif