{-# LANGUAGE ImplicitParams, RankNTypes, 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.Stage.Stage' 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.Stage
    ( 
#if defined(ENABLE_OVERLOADING)
    StageReadPixelsMethodInfo               ,
#endif

-- * Exported types
    Stage(..)                               ,
    IsStage                                 ,
    toStage                                 ,


 -- * 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"), [ensureCurrent]("GI.Clutter.Objects.Stage#g:method:ensureCurrent"), [ensureRedraw]("GI.Clutter.Objects.Stage#g:method:ensureRedraw"), [ensureViewport]("GI.Clutter.Objects.Stage#g:method:ensureViewport"), [event]("GI.Clutter.Objects.Stage#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"), [hideCursor]("GI.Clutter.Objects.Stage#g:method:hideCursor"), [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"), [isDefault]("GI.Clutter.Objects.Stage#g:method:isDefault"), [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.Stage#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"), [readPixels]("GI.Clutter.Objects.Stage#g:method:readPixels"), [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"), [removeAll]("GI.Clutter.Objects.Group#g:method:removeAll"), [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"), [showCursor]("GI.Clutter.Objects.Stage#g:method:showCursor"), [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"), [getAcceptFocus]("GI.Clutter.Objects.Stage#g:method:getAcceptFocus"), [getAccessible]("GI.Clutter.Objects.Actor#g:method:getAccessible"), [getAction]("GI.Clutter.Objects.Actor#g:method:getAction"), [getActions]("GI.Clutter.Objects.Actor#g:method:getActions"), [getActorAtPos]("GI.Clutter.Objects.Stage#g:method:getActorAtPos"), [getAllocationBox]("GI.Clutter.Objects.Actor#g:method:getAllocationBox"), [getAllocationGeometry]("GI.Clutter.Objects.Actor#g:method:getAllocationGeometry"), [getAllocationVertices]("GI.Clutter.Objects.Actor#g:method:getAllocationVertices"), [getAnchorPoint]("GI.Clutter.Objects.Actor#g:method:getAnchorPoint"), [getAnchorPointGravity]("GI.Clutter.Objects.Actor#g:method:getAnchorPointGravity"), [getAnimation]("GI.Clutter.Objects.Actor#g:method:getAnimation"), [getBackgroundColor]("GI.Clutter.Objects.Actor#g:method:getBackgroundColor"), [getChildAtIndex]("GI.Clutter.Objects.Actor#g:method:getChildAtIndex"), [getChildMeta]("GI.Clutter.Interfaces.Container#g:method:getChildMeta"), [getChildTransform]("GI.Clutter.Objects.Actor#g:method:getChildTransform"), [getChildren]("GI.Clutter.Objects.Actor#g:method:getChildren"), [getClip]("GI.Clutter.Objects.Actor#g:method:getClip"), [getClipToAllocation]("GI.Clutter.Objects.Actor#g:method:getClipToAllocation"), [getColor]("GI.Clutter.Objects.Stage#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"), [getFog]("GI.Clutter.Objects.Stage#g:method:getFog"), [getFullscreen]("GI.Clutter.Objects.Stage#g:method:getFullscreen"), [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"), [getKeyFocus]("GI.Clutter.Objects.Stage#g:method:getKeyFocus"), [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"), [getMinimumSize]("GI.Clutter.Objects.Stage#g:method:getMinimumSize"), [getMotionEventsEnabled]("GI.Clutter.Objects.Stage#g:method:getMotionEventsEnabled"), [getNChildren]("GI.Clutter.Objects.Group#g:method:getNChildren"), [getName]("GI.Clutter.Objects.Actor#g:method:getName"), [getNextSibling]("GI.Clutter.Objects.Actor#g:method:getNextSibling"), [getNoClearHint]("GI.Clutter.Objects.Stage#g:method:getNoClearHint"), [getNthChild]("GI.Clutter.Objects.Group#g:method:getNthChild"), [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"), [getPerspective]("GI.Clutter.Objects.Stage#g:method:getPerspective"), [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"), [getRedrawClipBounds]("GI.Clutter.Objects.Stage#g:method:getRedrawClipBounds"), [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"), [getThrottleMotionEvents]("GI.Clutter.Objects.Stage#g:method:getThrottleMotionEvents"), [getTitle]("GI.Clutter.Objects.Stage#g:method:getTitle"), [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"), [getUseAlpha]("GI.Clutter.Objects.Stage#g:method:getUseAlpha"), [getUseFog]("GI.Clutter.Objects.Stage#g:method:getUseFog"), [getUserResizable]("GI.Clutter.Objects.Stage#g:method:getUserResizable"), [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
-- [setAcceptFocus]("GI.Clutter.Objects.Stage#g:method:setAcceptFocus"), [setAllocation]("GI.Clutter.Objects.Actor#g:method:setAllocation"), [setAnchorPoint]("GI.Clutter.Objects.Actor#g:method:setAnchorPoint"), [setAnchorPointFromGravity]("GI.Clutter.Objects.Actor#g:method:setAnchorPointFromGravity"), [setBackgroundColor]("GI.Clutter.Objects.Actor#g:method:setBackgroundColor"), [setChildAboveSibling]("GI.Clutter.Objects.Actor#g:method:setChildAboveSibling"), [setChildAtIndex]("GI.Clutter.Objects.Actor#g:method:setChildAtIndex"), [setChildBelowSibling]("GI.Clutter.Objects.Actor#g:method:setChildBelowSibling"), [setChildTransform]("GI.Clutter.Objects.Actor#g:method:setChildTransform"), [setClip]("GI.Clutter.Objects.Actor#g:method:setClip"), [setClipToAllocation]("GI.Clutter.Objects.Actor#g:method:setClipToAllocation"), [setColor]("GI.Clutter.Objects.Stage#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"), [setFog]("GI.Clutter.Objects.Stage#g:method:setFog"), [setFullscreen]("GI.Clutter.Objects.Stage#g:method:setFullscreen"), [setGeometry]("GI.Clutter.Objects.Actor#g:method:setGeometry"), [setHeight]("GI.Clutter.Objects.Actor#g:method:setHeight"), [setId]("GI.Clutter.Interfaces.Scriptable#g:method:setId"), [setKeyFocus]("GI.Clutter.Objects.Stage#g:method:setKeyFocus"), [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"), [setMinimumSize]("GI.Clutter.Objects.Stage#g:method:setMinimumSize"), [setMotionEventsEnabled]("GI.Clutter.Objects.Stage#g:method:setMotionEventsEnabled"), [setName]("GI.Clutter.Objects.Actor#g:method:setName"), [setNoClearHint]("GI.Clutter.Objects.Stage#g:method:setNoClearHint"), [setOffscreenRedirect]("GI.Clutter.Objects.Actor#g:method:setOffscreenRedirect"), [setOpacity]("GI.Clutter.Objects.Actor#g:method:setOpacity"), [setParent]("GI.Clutter.Objects.Actor#g:method:setParent"), [setPerspective]("GI.Clutter.Objects.Stage#g:method:setPerspective"), [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"), [setThrottleMotionEvents]("GI.Clutter.Objects.Stage#g:method:setThrottleMotionEvents"), [setTitle]("GI.Clutter.Objects.Stage#g:method:setTitle"), [setTransform]("GI.Clutter.Objects.Actor#g:method:setTransform"), [setTranslation]("GI.Clutter.Objects.Actor#g:method:setTranslation"), [setUseAlpha]("GI.Clutter.Objects.Stage#g:method:setUseAlpha"), [setUseFog]("GI.Clutter.Objects.Stage#g:method:setUseFog"), [setUserResizable]("GI.Clutter.Objects.Stage#g:method:setUserResizable"), [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)
    ResolveStageMethod                      ,
#endif

-- ** ensureCurrent #method:ensureCurrent#

#if defined(ENABLE_OVERLOADING)
    StageEnsureCurrentMethodInfo            ,
#endif
    stageEnsureCurrent                      ,


-- ** ensureRedraw #method:ensureRedraw#

#if defined(ENABLE_OVERLOADING)
    StageEnsureRedrawMethodInfo             ,
#endif
    stageEnsureRedraw                       ,


-- ** ensureViewport #method:ensureViewport#

#if defined(ENABLE_OVERLOADING)
    StageEnsureViewportMethodInfo           ,
#endif
    stageEnsureViewport                     ,


-- ** event #method:event#

#if defined(ENABLE_OVERLOADING)
    StageEventMethodInfo                    ,
#endif
    stageEvent                              ,


-- ** getAcceptFocus #method:getAcceptFocus#

#if defined(ENABLE_OVERLOADING)
    StageGetAcceptFocusMethodInfo           ,
#endif
    stageGetAcceptFocus                     ,


-- ** getActorAtPos #method:getActorAtPos#

#if defined(ENABLE_OVERLOADING)
    StageGetActorAtPosMethodInfo            ,
#endif
    stageGetActorAtPos                      ,


-- ** getColor #method:getColor#

#if defined(ENABLE_OVERLOADING)
    StageGetColorMethodInfo                 ,
#endif
    stageGetColor                           ,


-- ** getDefault #method:getDefault#

    stageGetDefault                         ,


-- ** getFog #method:getFog#

#if defined(ENABLE_OVERLOADING)
    StageGetFogMethodInfo                   ,
#endif
    stageGetFog                             ,


-- ** getFullscreen #method:getFullscreen#

#if defined(ENABLE_OVERLOADING)
    StageGetFullscreenMethodInfo            ,
#endif
    stageGetFullscreen                      ,


-- ** getKeyFocus #method:getKeyFocus#

#if defined(ENABLE_OVERLOADING)
    StageGetKeyFocusMethodInfo              ,
#endif
    stageGetKeyFocus                        ,


-- ** getMinimumSize #method:getMinimumSize#

#if defined(ENABLE_OVERLOADING)
    StageGetMinimumSizeMethodInfo           ,
#endif
    stageGetMinimumSize                     ,


-- ** getMotionEventsEnabled #method:getMotionEventsEnabled#

#if defined(ENABLE_OVERLOADING)
    StageGetMotionEventsEnabledMethodInfo   ,
#endif
    stageGetMotionEventsEnabled             ,


-- ** getNoClearHint #method:getNoClearHint#

#if defined(ENABLE_OVERLOADING)
    StageGetNoClearHintMethodInfo           ,
#endif
    stageGetNoClearHint                     ,


-- ** getPerspective #method:getPerspective#

#if defined(ENABLE_OVERLOADING)
    StageGetPerspectiveMethodInfo           ,
#endif
    stageGetPerspective                     ,


-- ** getRedrawClipBounds #method:getRedrawClipBounds#

#if defined(ENABLE_OVERLOADING)
    StageGetRedrawClipBoundsMethodInfo      ,
#endif
    stageGetRedrawClipBounds                ,


-- ** getThrottleMotionEvents #method:getThrottleMotionEvents#

#if defined(ENABLE_OVERLOADING)
    StageGetThrottleMotionEventsMethodInfo  ,
#endif
    stageGetThrottleMotionEvents            ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    StageGetTitleMethodInfo                 ,
#endif
    stageGetTitle                           ,


-- ** getUseAlpha #method:getUseAlpha#

#if defined(ENABLE_OVERLOADING)
    StageGetUseAlphaMethodInfo              ,
#endif
    stageGetUseAlpha                        ,


-- ** getUseFog #method:getUseFog#

#if defined(ENABLE_OVERLOADING)
    StageGetUseFogMethodInfo                ,
#endif
    stageGetUseFog                          ,


-- ** getUserResizable #method:getUserResizable#

#if defined(ENABLE_OVERLOADING)
    StageGetUserResizableMethodInfo         ,
#endif
    stageGetUserResizable                   ,


-- ** hideCursor #method:hideCursor#

#if defined(ENABLE_OVERLOADING)
    StageHideCursorMethodInfo               ,
#endif
    stageHideCursor                         ,


-- ** isDefault #method:isDefault#

#if defined(ENABLE_OVERLOADING)
    StageIsDefaultMethodInfo                ,
#endif
    stageIsDefault                          ,


-- ** new #method:new#

    stageNew                                ,


-- ** queueRedraw #method:queueRedraw#

#if defined(ENABLE_OVERLOADING)
    StageQueueRedrawMethodInfo              ,
#endif
    stageQueueRedraw                        ,


-- ** setAcceptFocus #method:setAcceptFocus#

#if defined(ENABLE_OVERLOADING)
    StageSetAcceptFocusMethodInfo           ,
#endif
    stageSetAcceptFocus                     ,


-- ** setColor #method:setColor#

#if defined(ENABLE_OVERLOADING)
    StageSetColorMethodInfo                 ,
#endif
    stageSetColor                           ,


-- ** setFog #method:setFog#

#if defined(ENABLE_OVERLOADING)
    StageSetFogMethodInfo                   ,
#endif
    stageSetFog                             ,


-- ** setFullscreen #method:setFullscreen#

#if defined(ENABLE_OVERLOADING)
    StageSetFullscreenMethodInfo            ,
#endif
    stageSetFullscreen                      ,


-- ** setKeyFocus #method:setKeyFocus#

#if defined(ENABLE_OVERLOADING)
    StageSetKeyFocusMethodInfo              ,
#endif
    stageSetKeyFocus                        ,


-- ** setMinimumSize #method:setMinimumSize#

#if defined(ENABLE_OVERLOADING)
    StageSetMinimumSizeMethodInfo           ,
#endif
    stageSetMinimumSize                     ,


-- ** setMotionEventsEnabled #method:setMotionEventsEnabled#

#if defined(ENABLE_OVERLOADING)
    StageSetMotionEventsEnabledMethodInfo   ,
#endif
    stageSetMotionEventsEnabled             ,


-- ** setNoClearHint #method:setNoClearHint#

#if defined(ENABLE_OVERLOADING)
    StageSetNoClearHintMethodInfo           ,
#endif
    stageSetNoClearHint                     ,


-- ** setPerspective #method:setPerspective#

#if defined(ENABLE_OVERLOADING)
    StageSetPerspectiveMethodInfo           ,
#endif
    stageSetPerspective                     ,


-- ** setThrottleMotionEvents #method:setThrottleMotionEvents#

#if defined(ENABLE_OVERLOADING)
    StageSetThrottleMotionEventsMethodInfo  ,
#endif
    stageSetThrottleMotionEvents            ,


-- ** setTitle #method:setTitle#

#if defined(ENABLE_OVERLOADING)
    StageSetTitleMethodInfo                 ,
#endif
    stageSetTitle                           ,


-- ** setUseAlpha #method:setUseAlpha#

#if defined(ENABLE_OVERLOADING)
    StageSetUseAlphaMethodInfo              ,
#endif
    stageSetUseAlpha                        ,


-- ** setUseFog #method:setUseFog#

#if defined(ENABLE_OVERLOADING)
    StageSetUseFogMethodInfo                ,
#endif
    stageSetUseFog                          ,


-- ** setUserResizable #method:setUserResizable#

#if defined(ENABLE_OVERLOADING)
    StageSetUserResizableMethodInfo         ,
#endif
    stageSetUserResizable                   ,


-- ** showCursor #method:showCursor#

#if defined(ENABLE_OVERLOADING)
    StageShowCursorMethodInfo               ,
#endif
    stageShowCursor                         ,




 -- * Properties


-- ** acceptFocus #attr:acceptFocus#
-- | Whether the t'GI.Clutter.Objects.Stage.Stage' should accept key focus when shown.
-- 
-- /Since: 1.6/

#if defined(ENABLE_OVERLOADING)
    StageAcceptFocusPropertyInfo            ,
#endif
    constructStageAcceptFocus               ,
    getStageAcceptFocus                     ,
    setStageAcceptFocus                     ,
#if defined(ENABLE_OVERLOADING)
    stageAcceptFocus                        ,
#endif


-- ** color #attr:color#
-- | The background color of the main stage.

#if defined(ENABLE_OVERLOADING)
    StageColorPropertyInfo                  ,
#endif
    constructStageColor                     ,
    getStageColor                           ,
    setStageColor                           ,
#if defined(ENABLE_OVERLOADING)
    stageColor                              ,
#endif


-- ** cursorVisible #attr:cursorVisible#
-- | Whether the mouse pointer should be visible

#if defined(ENABLE_OVERLOADING)
    StageCursorVisiblePropertyInfo          ,
#endif
    constructStageCursorVisible             ,
    getStageCursorVisible                   ,
    setStageCursorVisible                   ,
#if defined(ENABLE_OVERLOADING)
    stageCursorVisible                      ,
#endif


-- ** fog #attr:fog#
-- | The settings for the GL \"fog\", used only if t'GI.Clutter.Objects.Stage.Stage':@/use-fog/@
-- is set to 'P.True'
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    StageFogPropertyInfo                    ,
#endif
    constructStageFog                       ,
    getStageFog                             ,
    setStageFog                             ,
#if defined(ENABLE_OVERLOADING)
    stageFog                                ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    StageFullscreenSetPropertyInfo          ,
#endif
    getStageFullscreenSet                   ,
#if defined(ENABLE_OVERLOADING)
    stageFullscreenSet                      ,
#endif


-- ** keyFocus #attr:keyFocus#
-- | The t'GI.Clutter.Objects.Actor.Actor' that will receive key events from the underlying
-- windowing system.
-- 
-- If 'P.Nothing', the t'GI.Clutter.Objects.Stage.Stage' will receive the events.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    StageKeyFocusPropertyInfo               ,
#endif
    clearStageKeyFocus                      ,
    constructStageKeyFocus                  ,
    getStageKeyFocus                        ,
    setStageKeyFocus                        ,
#if defined(ENABLE_OVERLOADING)
    stageKeyFocus                           ,
#endif


-- ** noClearHint #attr:noClearHint#
-- | Whether or not the t'GI.Clutter.Objects.Stage.Stage' should clear its contents
-- before each paint cycle.
-- 
-- See 'GI.Clutter.Objects.Stage.stageSetNoClearHint' for further information.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    StageNoClearHintPropertyInfo            ,
#endif
    constructStageNoClearHint               ,
    getStageNoClearHint                     ,
    setStageNoClearHint                     ,
#if defined(ENABLE_OVERLOADING)
    stageNoClearHint                        ,
#endif


-- ** offscreen #attr:offscreen#
-- | Whether the stage should be rendered in an offscreen buffer.

#if defined(ENABLE_OVERLOADING)
    StageOffscreenPropertyInfo              ,
#endif
    constructStageOffscreen                 ,
    getStageOffscreen                       ,
    setStageOffscreen                       ,
#if defined(ENABLE_OVERLOADING)
    stageOffscreen                          ,
#endif


-- ** perspective #attr:perspective#
-- | The parameters used for the perspective projection from 3D
-- coordinates to 2D
-- 
-- /Since: 0.8/

#if defined(ENABLE_OVERLOADING)
    StagePerspectivePropertyInfo            ,
#endif
    constructStagePerspective               ,
    getStagePerspective                     ,
    setStagePerspective                     ,
#if defined(ENABLE_OVERLOADING)
    stagePerspective                        ,
#endif


-- ** title #attr:title#
-- | The stage\'s title - usually displayed in stage windows title decorations.
-- 
-- /Since: 0.4/

#if defined(ENABLE_OVERLOADING)
    StageTitlePropertyInfo                  ,
#endif
    constructStageTitle                     ,
    getStageTitle                           ,
    setStageTitle                           ,
#if defined(ENABLE_OVERLOADING)
    stageTitle                              ,
#endif


-- ** useAlpha #attr:useAlpha#
-- | Whether the t'GI.Clutter.Objects.Stage.Stage' should honour the alpha component of the
-- t'GI.Clutter.Objects.Stage.Stage':@/color/@ property when painting. If Clutter is run under
-- a compositing manager this will result in the stage being blended
-- with the underlying window(s)
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    StageUseAlphaPropertyInfo               ,
#endif
    constructStageUseAlpha                  ,
    getStageUseAlpha                        ,
    setStageUseAlpha                        ,
#if defined(ENABLE_OVERLOADING)
    stageUseAlpha                           ,
#endif


-- ** useFog #attr:useFog#
-- | Whether the stage should use a linear GL \"fog\" in creating the
-- depth-cueing effect, to enhance the perception of depth by fading
-- actors farther from the viewpoint.
-- 
-- /Since: 0.6/

#if defined(ENABLE_OVERLOADING)
    StageUseFogPropertyInfo                 ,
#endif
    constructStageUseFog                    ,
    getStageUseFog                          ,
    setStageUseFog                          ,
#if defined(ENABLE_OVERLOADING)
    stageUseFog                             ,
#endif


-- ** userResizable #attr:userResizable#
-- | Whether the stage is resizable via user interaction.
-- 
-- /Since: 0.4/

#if defined(ENABLE_OVERLOADING)
    StageUserResizablePropertyInfo          ,
#endif
    constructStageUserResizable             ,
    getStageUserResizable                   ,
    setStageUserResizable                   ,
#if defined(ENABLE_OVERLOADING)
    stageUserResizable                      ,
#endif




 -- * Signals


-- ** activate #signal:activate#

    StageActivateCallback                   ,
#if defined(ENABLE_OVERLOADING)
    StageActivateSignalInfo                 ,
#endif
    afterStageActivate                      ,
    onStageActivate                         ,


-- ** afterPaint #signal:afterPaint#

    StageAfterPaintCallback                 ,
#if defined(ENABLE_OVERLOADING)
    StageAfterPaintSignalInfo               ,
#endif
    afterStageAfterPaint                    ,
    onStageAfterPaint                       ,


-- ** deactivate #signal:deactivate#

    StageDeactivateCallback                 ,
#if defined(ENABLE_OVERLOADING)
    StageDeactivateSignalInfo               ,
#endif
    afterStageDeactivate                    ,
    onStageDeactivate                       ,


-- ** deleteEvent #signal:deleteEvent#

    StageDeleteEventCallback                ,
#if defined(ENABLE_OVERLOADING)
    StageDeleteEventSignalInfo              ,
#endif
    afterStageDeleteEvent                   ,
    onStageDeleteEvent                      ,


-- ** fullscreen #signal:fullscreen#

    StageFullscreenCallback                 ,
#if defined(ENABLE_OVERLOADING)
    StageFullscreenSignalInfo               ,
#endif
    afterStageFullscreen                    ,
    onStageFullscreen                       ,


-- ** unfullscreen #signal:unfullscreen#

    StageUnfullscreenCallback               ,
#if defined(ENABLE_OVERLOADING)
    StageUnfullscreenSignalInfo             ,
#endif
    afterStageUnfullscreen                  ,
    onStageUnfullscreen                     ,




    ) 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 qualified GI.Cairo.Structs.RectangleInt as Cairo.RectangleInt
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
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.Objects.Group as Clutter.Group
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import {-# SOURCE #-} qualified GI.Clutter.Structs.Fog as Clutter.Fog
import {-# SOURCE #-} qualified GI.Clutter.Structs.Perspective as Clutter.Perspective
import {-# SOURCE #-} qualified GI.Clutter.Unions.Event as Clutter.Event
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "clutter_stage_get_type"
    c_clutter_stage_get_type :: IO B.Types.GType

instance B.Types.TypedObject Stage where
    glibType :: IO GType
glibType = IO GType
c_clutter_stage_get_type

instance B.Types.GObject Stage

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

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

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

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

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

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

#endif

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

#endif

-- signal Stage::activate
-- | The [activate](#g:signal:activate) signal is emitted when the stage receives key focus
-- from the underlying window system.
-- 
-- /Since: 0.6/
type StageActivateCallback =
    IO ()

type C_StageActivateCallback =
    Ptr Stage ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_StageActivateCallback :: 
    GObject a => (a -> StageActivateCallback) ->
    C_StageActivateCallback
wrap_StageActivateCallback :: forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageActivateCallback a -> IO ()
gi'cb Ptr Stage
gi'selfPtr Ptr ()
_ = do
    Ptr Stage -> (Stage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Stage
gi'selfPtr ((Stage -> IO ()) -> IO ()) -> (Stage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Stage
gi'self -> a -> IO ()
gi'cb (Stage -> a
Coerce.coerce Stage
gi'self) 


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

-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' stage #activate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterStageActivate :: (IsStage a, MonadIO m) => a -> ((?self :: a) => StageActivateCallback) -> m SignalHandlerId
afterStageActivate :: forall a (m :: * -> *).
(IsStage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterStageActivate a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_StageActivateCallback
wrapped' = (a -> IO ()) -> C_StageActivateCallback
forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageActivateCallback a -> IO ()
wrapped
    FunPtr C_StageActivateCallback
wrapped'' <- C_StageActivateCallback -> IO (FunPtr C_StageActivateCallback)
mk_StageActivateCallback C_StageActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_StageActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_StageActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data StageActivateSignalInfo
instance SignalInfo StageActivateSignalInfo where
    type HaskellCallbackType StageActivateSignalInfo = StageActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_StageActivateCallback cb
        cb'' <- mk_StageActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage::activate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:signal:activate"})

#endif

-- signal Stage::after-paint
-- | The [afterPaint](#g:signal:afterPaint) signal is emitted after the stage is painted,
-- but before the results are displayed on the screen.
-- 
-- /Since: 1.20/
type StageAfterPaintCallback =
    IO ()

type C_StageAfterPaintCallback =
    Ptr Stage ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_StageAfterPaintCallback :: 
    GObject a => (a -> StageAfterPaintCallback) ->
    C_StageAfterPaintCallback
wrap_StageAfterPaintCallback :: forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageAfterPaintCallback a -> IO ()
gi'cb Ptr Stage
gi'selfPtr Ptr ()
_ = do
    Ptr Stage -> (Stage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Stage
gi'selfPtr ((Stage -> IO ()) -> IO ()) -> (Stage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Stage
gi'self -> a -> IO ()
gi'cb (Stage -> a
Coerce.coerce Stage
gi'self) 


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

-- | Connect a signal handler for the [afterPaint](#signal:afterPaint) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' stage #afterPaint callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterStageAfterPaint :: (IsStage a, MonadIO m) => a -> ((?self :: a) => StageAfterPaintCallback) -> m SignalHandlerId
afterStageAfterPaint :: forall a (m :: * -> *).
(IsStage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterStageAfterPaint a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_StageActivateCallback
wrapped' = (a -> IO ()) -> C_StageActivateCallback
forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageAfterPaintCallback a -> IO ()
wrapped
    FunPtr C_StageActivateCallback
wrapped'' <- C_StageActivateCallback -> IO (FunPtr C_StageActivateCallback)
mk_StageAfterPaintCallback C_StageActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_StageActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"after-paint" FunPtr C_StageActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data StageAfterPaintSignalInfo
instance SignalInfo StageAfterPaintSignalInfo where
    type HaskellCallbackType StageAfterPaintSignalInfo = StageAfterPaintCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_StageAfterPaintCallback cb
        cb'' <- mk_StageAfterPaintCallback cb'
        connectSignalFunPtr obj "after-paint" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage::after-paint"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:signal:afterPaint"})

#endif

-- signal Stage::deactivate
-- | The [deactivate](#g:signal:deactivate) signal is emitted when the stage loses key focus
-- from the underlying window system.
-- 
-- /Since: 0.6/
type StageDeactivateCallback =
    IO ()

type C_StageDeactivateCallback =
    Ptr Stage ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_StageDeactivateCallback :: 
    GObject a => (a -> StageDeactivateCallback) ->
    C_StageDeactivateCallback
wrap_StageDeactivateCallback :: forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageDeactivateCallback a -> IO ()
gi'cb Ptr Stage
gi'selfPtr Ptr ()
_ = do
    Ptr Stage -> (Stage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Stage
gi'selfPtr ((Stage -> IO ()) -> IO ()) -> (Stage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Stage
gi'self -> a -> IO ()
gi'cb (Stage -> a
Coerce.coerce Stage
gi'self) 


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

-- | Connect a signal handler for the [deactivate](#signal:deactivate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' stage #deactivate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterStageDeactivate :: (IsStage a, MonadIO m) => a -> ((?self :: a) => StageDeactivateCallback) -> m SignalHandlerId
afterStageDeactivate :: forall a (m :: * -> *).
(IsStage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterStageDeactivate a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_StageActivateCallback
wrapped' = (a -> IO ()) -> C_StageActivateCallback
forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageDeactivateCallback a -> IO ()
wrapped
    FunPtr C_StageActivateCallback
wrapped'' <- C_StageActivateCallback -> IO (FunPtr C_StageActivateCallback)
mk_StageDeactivateCallback C_StageActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_StageActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"deactivate" FunPtr C_StageActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data StageDeactivateSignalInfo
instance SignalInfo StageDeactivateSignalInfo where
    type HaskellCallbackType StageDeactivateSignalInfo = StageDeactivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_StageDeactivateCallback cb
        cb'' <- mk_StageDeactivateCallback cb'
        connectSignalFunPtr obj "deactivate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage::deactivate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:signal:deactivate"})

#endif

-- signal Stage::delete-event
-- | The [deleteEvent](#g:signal:deleteEvent) signal is emitted when the user closes a
-- t'GI.Clutter.Objects.Stage.Stage' window using the window controls.
-- 
-- Clutter by default will call 'GI.Clutter.Functions.mainQuit' if /@stage@/ is
-- the default stage, and 'GI.Clutter.Objects.Actor.actorDestroy' for any other
-- stage.
-- 
-- It is possible to override the default behaviour by connecting
-- a new handler and returning 'P.True' there.
-- 
-- This signal is emitted only on Clutter backends that
-- embed t'GI.Clutter.Objects.Stage.Stage' in native windows. It is not emitted for
-- backends that use a static frame buffer.
-- 
-- /Since: 1.2/
type StageDeleteEventCallback =
    Clutter.Event.Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeDelete'
    -> IO Bool

type C_StageDeleteEventCallback =
    Ptr Stage ->                            -- object
    Ptr Clutter.Event.Event ->
    Ptr () ->                               -- user_data
    IO CInt

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

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


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

-- | Connect a signal handler for the [deleteEvent](#signal:deleteEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' stage #deleteEvent callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterStageDeleteEvent :: (IsStage a, MonadIO m) => a -> ((?self :: a) => StageDeleteEventCallback) -> m SignalHandlerId
afterStageDeleteEvent :: forall a (m :: * -> *).
(IsStage a, MonadIO m) =>
a -> ((?self::a) => StageDeleteEventCallback) -> m SignalHandlerId
afterStageDeleteEvent a
obj (?self::a) => StageDeleteEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> StageDeleteEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => StageDeleteEventCallback
StageDeleteEventCallback
cb
    let wrapped' :: C_StageDeleteEventCallback
wrapped' = (a -> StageDeleteEventCallback) -> C_StageDeleteEventCallback
forall a.
GObject a =>
(a -> StageDeleteEventCallback) -> C_StageDeleteEventCallback
wrap_StageDeleteEventCallback a -> StageDeleteEventCallback
wrapped
    FunPtr C_StageDeleteEventCallback
wrapped'' <- C_StageDeleteEventCallback
-> IO (FunPtr C_StageDeleteEventCallback)
mk_StageDeleteEventCallback C_StageDeleteEventCallback
wrapped'
    a
-> Text
-> FunPtr C_StageDeleteEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"delete-event" FunPtr C_StageDeleteEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data StageDeleteEventSignalInfo
instance SignalInfo StageDeleteEventSignalInfo where
    type HaskellCallbackType StageDeleteEventSignalInfo = StageDeleteEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_StageDeleteEventCallback cb
        cb'' <- mk_StageDeleteEventCallback cb'
        connectSignalFunPtr obj "delete-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage::delete-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:signal:deleteEvent"})

#endif

-- signal Stage::fullscreen
-- | The [fullscreen](#g:signal:fullscreen) signal is emitted when the stage is made fullscreen.
-- 
-- /Since: 0.6/
type StageFullscreenCallback =
    IO ()

type C_StageFullscreenCallback =
    Ptr Stage ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_StageFullscreenCallback :: 
    GObject a => (a -> StageFullscreenCallback) ->
    C_StageFullscreenCallback
wrap_StageFullscreenCallback :: forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageFullscreenCallback a -> IO ()
gi'cb Ptr Stage
gi'selfPtr Ptr ()
_ = do
    Ptr Stage -> (Stage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Stage
gi'selfPtr ((Stage -> IO ()) -> IO ()) -> (Stage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Stage
gi'self -> a -> IO ()
gi'cb (Stage -> a
Coerce.coerce Stage
gi'self) 


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

-- | Connect a signal handler for the [fullscreen](#signal:fullscreen) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' stage #fullscreen callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterStageFullscreen :: (IsStage a, MonadIO m) => a -> ((?self :: a) => StageFullscreenCallback) -> m SignalHandlerId
afterStageFullscreen :: forall a (m :: * -> *).
(IsStage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterStageFullscreen a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_StageActivateCallback
wrapped' = (a -> IO ()) -> C_StageActivateCallback
forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageFullscreenCallback a -> IO ()
wrapped
    FunPtr C_StageActivateCallback
wrapped'' <- C_StageActivateCallback -> IO (FunPtr C_StageActivateCallback)
mk_StageFullscreenCallback C_StageActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_StageActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"fullscreen" FunPtr C_StageActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data StageFullscreenSignalInfo
instance SignalInfo StageFullscreenSignalInfo where
    type HaskellCallbackType StageFullscreenSignalInfo = StageFullscreenCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_StageFullscreenCallback cb
        cb'' <- mk_StageFullscreenCallback cb'
        connectSignalFunPtr obj "fullscreen" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage::fullscreen"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:signal:fullscreen"})

#endif

-- signal Stage::unfullscreen
-- | The [unfullscreen](#g:signal:unfullscreen) signal is emitted when the stage leaves a fullscreen
-- state.
-- 
-- /Since: 0.6/
type StageUnfullscreenCallback =
    IO ()

type C_StageUnfullscreenCallback =
    Ptr Stage ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_StageUnfullscreenCallback :: 
    GObject a => (a -> StageUnfullscreenCallback) ->
    C_StageUnfullscreenCallback
wrap_StageUnfullscreenCallback :: forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageUnfullscreenCallback a -> IO ()
gi'cb Ptr Stage
gi'selfPtr Ptr ()
_ = do
    Ptr Stage -> (Stage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Stage
gi'selfPtr ((Stage -> IO ()) -> IO ()) -> (Stage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Stage
gi'self -> a -> IO ()
gi'cb (Stage -> a
Coerce.coerce Stage
gi'self) 


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

-- | Connect a signal handler for the [unfullscreen](#signal:unfullscreen) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' stage #unfullscreen callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterStageUnfullscreen :: (IsStage a, MonadIO m) => a -> ((?self :: a) => StageUnfullscreenCallback) -> m SignalHandlerId
afterStageUnfullscreen :: forall a (m :: * -> *).
(IsStage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterStageUnfullscreen a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_StageActivateCallback
wrapped' = (a -> IO ()) -> C_StageActivateCallback
forall a. GObject a => (a -> IO ()) -> C_StageActivateCallback
wrap_StageUnfullscreenCallback a -> IO ()
wrapped
    FunPtr C_StageActivateCallback
wrapped'' <- C_StageActivateCallback -> IO (FunPtr C_StageActivateCallback)
mk_StageUnfullscreenCallback C_StageActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_StageActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unfullscreen" FunPtr C_StageActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data StageUnfullscreenSignalInfo
instance SignalInfo StageUnfullscreenSignalInfo where
    type HaskellCallbackType StageUnfullscreenSignalInfo = StageUnfullscreenCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_StageUnfullscreenCallback cb
        cb'' <- mk_StageUnfullscreenCallback cb'
        connectSignalFunPtr obj "unfullscreen" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage::unfullscreen"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:signal:unfullscreen"})

#endif

-- VVV Prop "accept-focus"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@accept-focus@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stage #acceptFocus
-- @
getStageAcceptFocus :: (MonadIO m, IsStage o) => o -> m Bool
getStageAcceptFocus :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> m Bool
getStageAcceptFocus 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
"accept-focus"

-- | Set the value of the “@accept-focus@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #acceptFocus 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageAcceptFocus :: (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageAcceptFocus :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageAcceptFocus 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
"accept-focus" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data StageAcceptFocusPropertyInfo
instance AttrInfo StageAcceptFocusPropertyInfo where
    type AttrAllowedOps StageAcceptFocusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StageAcceptFocusPropertyInfo = IsStage
    type AttrSetTypeConstraint StageAcceptFocusPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StageAcceptFocusPropertyInfo = (~) Bool
    type AttrTransferType StageAcceptFocusPropertyInfo = Bool
    type AttrGetType StageAcceptFocusPropertyInfo = Bool
    type AttrLabel StageAcceptFocusPropertyInfo = "accept-focus"
    type AttrOrigin StageAcceptFocusPropertyInfo = Stage
    attrGet = getStageAcceptFocus
    attrSet = setStageAcceptFocus
    attrTransfer _ v = do
        return v
    attrConstruct = constructStageAcceptFocus
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.acceptFocus"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:acceptFocus"
        })
#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' stage #color
-- @
getStageColor :: (MonadIO m, IsStage o) => o -> m (Maybe Clutter.Color.Color)
getStageColor :: forall (m :: * -> *) o.
(MonadIO m, IsStage o) =>
o -> m (Maybe Color)
getStageColor 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' stage [ #color 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageColor :: (MonadIO m, IsStage o) => o -> Clutter.Color.Color -> m ()
setStageColor :: forall (m :: * -> *) o.
(MonadIO m, IsStage o) =>
o -> Color -> m ()
setStageColor 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`.
constructStageColor :: (IsStage o, MIO.MonadIO m) => Clutter.Color.Color -> m (GValueConstruct o)
constructStageColor :: forall o (m :: * -> *).
(IsStage o, MonadIO m) =>
Color -> m (GValueConstruct o)
constructStageColor 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 StageColorPropertyInfo
instance AttrInfo StageColorPropertyInfo where
    type AttrAllowedOps StageColorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StageColorPropertyInfo = IsStage
    type AttrSetTypeConstraint StageColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferTypeConstraint StageColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferType StageColorPropertyInfo = Clutter.Color.Color
    type AttrGetType StageColorPropertyInfo = (Maybe Clutter.Color.Color)
    type AttrLabel StageColorPropertyInfo = "color"
    type AttrOrigin StageColorPropertyInfo = Stage
    attrGet = getStageColor
    attrSet = setStageColor
    attrTransfer _ v = do
        return v
    attrConstruct = constructStageColor
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.color"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:color"
        })
#endif

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

-- | Get the value of the “@cursor-visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stage #cursorVisible
-- @
getStageCursorVisible :: (MonadIO m, IsStage o) => o -> m Bool
getStageCursorVisible :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> m Bool
getStageCursorVisible 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
"cursor-visible"

-- | Set the value of the “@cursor-visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #cursorVisible 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageCursorVisible :: (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageCursorVisible :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageCursorVisible 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
"cursor-visible" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data StageCursorVisiblePropertyInfo
instance AttrInfo StageCursorVisiblePropertyInfo where
    type AttrAllowedOps StageCursorVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StageCursorVisiblePropertyInfo = IsStage
    type AttrSetTypeConstraint StageCursorVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StageCursorVisiblePropertyInfo = (~) Bool
    type AttrTransferType StageCursorVisiblePropertyInfo = Bool
    type AttrGetType StageCursorVisiblePropertyInfo = Bool
    type AttrLabel StageCursorVisiblePropertyInfo = "cursor-visible"
    type AttrOrigin StageCursorVisiblePropertyInfo = Stage
    attrGet = getStageCursorVisible
    attrSet = setStageCursorVisible
    attrTransfer _ v = do
        return v
    attrConstruct = constructStageCursorVisible
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.cursorVisible"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:cursorVisible"
        })
#endif

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

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

-- | Set the value of the “@fog@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #fog 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageFog :: (MonadIO m, IsStage o) => o -> Clutter.Fog.Fog -> m ()
setStageFog :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> Fog -> m ()
setStageFog o
obj Fog
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 Fog -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"fog" (Fog -> Maybe Fog
forall a. a -> Maybe a
Just Fog
val)

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

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

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

-- | Get the value of the “@fullscreen-set@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stage #fullscreenSet
-- @
getStageFullscreenSet :: (MonadIO m, IsStage o) => o -> m Bool
getStageFullscreenSet :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> m Bool
getStageFullscreenSet 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
"fullscreen-set"

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

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

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

-- | Set the value of the “@key-focus@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #keyFocus 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageKeyFocus :: (MonadIO m, IsStage o, Clutter.Actor.IsActor a) => o -> a -> m ()
setStageKeyFocus :: forall (m :: * -> *) o a.
(MonadIO m, IsStage o, IsActor a) =>
o -> a -> m ()
setStageKeyFocus o
obj a
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 a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"key-focus" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@key-focus@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStageKeyFocus :: (IsStage o, MIO.MonadIO m, Clutter.Actor.IsActor a) => a -> m (GValueConstruct o)
constructStageKeyFocus :: forall o (m :: * -> *) a.
(IsStage o, MonadIO m, IsActor a) =>
a -> m (GValueConstruct o)
constructStageKeyFocus a
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 a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"key-focus" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data StageKeyFocusPropertyInfo
instance AttrInfo StageKeyFocusPropertyInfo where
    type AttrAllowedOps StageKeyFocusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint StageKeyFocusPropertyInfo = IsStage
    type AttrSetTypeConstraint StageKeyFocusPropertyInfo = Clutter.Actor.IsActor
    type AttrTransferTypeConstraint StageKeyFocusPropertyInfo = Clutter.Actor.IsActor
    type AttrTransferType StageKeyFocusPropertyInfo = Clutter.Actor.Actor
    type AttrGetType StageKeyFocusPropertyInfo = Clutter.Actor.Actor
    type AttrLabel StageKeyFocusPropertyInfo = "key-focus"
    type AttrOrigin StageKeyFocusPropertyInfo = Stage
    attrGet = getStageKeyFocus
    attrSet = setStageKeyFocus
    attrTransfer _ v = do
        unsafeCastTo Clutter.Actor.Actor v
    attrConstruct = constructStageKeyFocus
    attrClear = clearStageKeyFocus
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.keyFocus"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:keyFocus"
        })
#endif

-- VVV Prop "no-clear-hint"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@no-clear-hint@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stage #noClearHint
-- @
getStageNoClearHint :: (MonadIO m, IsStage o) => o -> m Bool
getStageNoClearHint :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> m Bool
getStageNoClearHint 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
"no-clear-hint"

-- | Set the value of the “@no-clear-hint@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #noClearHint 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageNoClearHint :: (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageNoClearHint :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageNoClearHint 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
"no-clear-hint" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data StageNoClearHintPropertyInfo
instance AttrInfo StageNoClearHintPropertyInfo where
    type AttrAllowedOps StageNoClearHintPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StageNoClearHintPropertyInfo = IsStage
    type AttrSetTypeConstraint StageNoClearHintPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StageNoClearHintPropertyInfo = (~) Bool
    type AttrTransferType StageNoClearHintPropertyInfo = Bool
    type AttrGetType StageNoClearHintPropertyInfo = Bool
    type AttrLabel StageNoClearHintPropertyInfo = "no-clear-hint"
    type AttrOrigin StageNoClearHintPropertyInfo = Stage
    attrGet = getStageNoClearHint
    attrSet = setStageNoClearHint
    attrTransfer _ v = do
        return v
    attrConstruct = constructStageNoClearHint
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.noClearHint"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:noClearHint"
        })
#endif

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

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

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

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

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

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

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

-- | Set the value of the “@perspective@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #perspective 'Data.GI.Base.Attributes.:=' value ]
-- @
setStagePerspective :: (MonadIO m, IsStage o) => o -> Clutter.Perspective.Perspective -> m ()
setStagePerspective :: forall (m :: * -> *) o.
(MonadIO m, IsStage o) =>
o -> Perspective -> m ()
setStagePerspective o
obj Perspective
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 Perspective -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"perspective" (Perspective -> Maybe Perspective
forall a. a -> Maybe a
Just Perspective
val)

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

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

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

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

-- | Set the value of the “@title@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #title 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageTitle :: (MonadIO m, IsStage o) => o -> T.Text -> m ()
setStageTitle :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> Text -> m ()
setStageTitle o
obj Text
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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"title" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@title@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructStageTitle :: (IsStage o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStageTitle :: forall o (m :: * -> *).
(IsStage o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStageTitle Text
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 Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"title" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data StageTitlePropertyInfo
instance AttrInfo StageTitlePropertyInfo where
    type AttrAllowedOps StageTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StageTitlePropertyInfo = IsStage
    type AttrSetTypeConstraint StageTitlePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint StageTitlePropertyInfo = (~) T.Text
    type AttrTransferType StageTitlePropertyInfo = T.Text
    type AttrGetType StageTitlePropertyInfo = T.Text
    type AttrLabel StageTitlePropertyInfo = "title"
    type AttrOrigin StageTitlePropertyInfo = Stage
    attrGet = getStageTitle
    attrSet = setStageTitle
    attrTransfer _ v = do
        return v
    attrConstruct = constructStageTitle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.title"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:title"
        })
#endif

-- VVV Prop "use-alpha"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@use-alpha@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stage #useAlpha
-- @
getStageUseAlpha :: (MonadIO m, IsStage o) => o -> m Bool
getStageUseAlpha :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> m Bool
getStageUseAlpha 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
"use-alpha"

-- | Set the value of the “@use-alpha@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #useAlpha 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageUseAlpha :: (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageUseAlpha :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageUseAlpha 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
"use-alpha" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data StageUseAlphaPropertyInfo
instance AttrInfo StageUseAlphaPropertyInfo where
    type AttrAllowedOps StageUseAlphaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StageUseAlphaPropertyInfo = IsStage
    type AttrSetTypeConstraint StageUseAlphaPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StageUseAlphaPropertyInfo = (~) Bool
    type AttrTransferType StageUseAlphaPropertyInfo = Bool
    type AttrGetType StageUseAlphaPropertyInfo = Bool
    type AttrLabel StageUseAlphaPropertyInfo = "use-alpha"
    type AttrOrigin StageUseAlphaPropertyInfo = Stage
    attrGet = getStageUseAlpha
    attrSet = setStageUseAlpha
    attrTransfer _ v = do
        return v
    attrConstruct = constructStageUseAlpha
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.useAlpha"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:useAlpha"
        })
#endif

-- VVV Prop "use-fog"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@use-fog@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stage #useFog
-- @
getStageUseFog :: (MonadIO m, IsStage o) => o -> m Bool
getStageUseFog :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> m Bool
getStageUseFog 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
"use-fog"

-- | Set the value of the “@use-fog@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #useFog 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageUseFog :: (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageUseFog :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageUseFog 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
"use-fog" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data StageUseFogPropertyInfo
instance AttrInfo StageUseFogPropertyInfo where
    type AttrAllowedOps StageUseFogPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StageUseFogPropertyInfo = IsStage
    type AttrSetTypeConstraint StageUseFogPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StageUseFogPropertyInfo = (~) Bool
    type AttrTransferType StageUseFogPropertyInfo = Bool
    type AttrGetType StageUseFogPropertyInfo = Bool
    type AttrLabel StageUseFogPropertyInfo = "use-fog"
    type AttrOrigin StageUseFogPropertyInfo = Stage
    attrGet = getStageUseFog
    attrSet = setStageUseFog
    attrTransfer _ v = do
        return v
    attrConstruct = constructStageUseFog
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.useFog"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:useFog"
        })
#endif

-- VVV Prop "user-resizable"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@user-resizable@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' stage #userResizable
-- @
getStageUserResizable :: (MonadIO m, IsStage o) => o -> m Bool
getStageUserResizable :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> m Bool
getStageUserResizable 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
"user-resizable"

-- | Set the value of the “@user-resizable@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' stage [ #userResizable 'Data.GI.Base.Attributes.:=' value ]
-- @
setStageUserResizable :: (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageUserResizable :: forall (m :: * -> *) o. (MonadIO m, IsStage o) => o -> Bool -> m ()
setStageUserResizable 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
"user-resizable" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data StageUserResizablePropertyInfo
instance AttrInfo StageUserResizablePropertyInfo where
    type AttrAllowedOps StageUserResizablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint StageUserResizablePropertyInfo = IsStage
    type AttrSetTypeConstraint StageUserResizablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint StageUserResizablePropertyInfo = (~) Bool
    type AttrTransferType StageUserResizablePropertyInfo = Bool
    type AttrGetType StageUserResizablePropertyInfo = Bool
    type AttrLabel StageUserResizablePropertyInfo = "user-resizable"
    type AttrOrigin StageUserResizablePropertyInfo = Stage
    attrGet = getStageUserResizable
    attrSet = setStageUserResizable
    attrTransfer _ v = do
        return v
    attrConstruct = constructStageUserResizable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Stage.userResizable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Stage.html#g:attr:userResizable"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Stage
type instance O.AttributeList Stage = StageAttributeList
type StageAttributeList = ('[ '("acceptFocus", StageAcceptFocusPropertyInfo), '("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), '("childTransform", Clutter.Actor.ActorChildTransformPropertyInfo), '("childTransformSet", Clutter.Actor.ActorChildTransformSetPropertyInfo), '("clip", Clutter.Actor.ActorClipPropertyInfo), '("clipRect", Clutter.Actor.ActorClipRectPropertyInfo), '("clipToAllocation", Clutter.Actor.ActorClipToAllocationPropertyInfo), '("color", StageColorPropertyInfo), '("constraints", Clutter.Actor.ActorConstraintsPropertyInfo), '("content", Clutter.Actor.ActorContentPropertyInfo), '("contentBox", Clutter.Actor.ActorContentBoxPropertyInfo), '("contentGravity", Clutter.Actor.ActorContentGravityPropertyInfo), '("contentRepeat", Clutter.Actor.ActorContentRepeatPropertyInfo), '("cursorVisible", StageCursorVisiblePropertyInfo), '("depth", Clutter.Actor.ActorDepthPropertyInfo), '("effect", Clutter.Actor.ActorEffectPropertyInfo), '("firstChild", Clutter.Actor.ActorFirstChildPropertyInfo), '("fixedPositionSet", Clutter.Actor.ActorFixedPositionSetPropertyInfo), '("fixedX", Clutter.Actor.ActorFixedXPropertyInfo), '("fixedY", Clutter.Actor.ActorFixedYPropertyInfo), '("fog", StageFogPropertyInfo), '("fullscreenSet", StageFullscreenSetPropertyInfo), '("hasClip", Clutter.Actor.ActorHasClipPropertyInfo), '("hasPointer", Clutter.Actor.ActorHasPointerPropertyInfo), '("height", Clutter.Actor.ActorHeightPropertyInfo), '("keyFocus", StageKeyFocusPropertyInfo), '("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), '("noClearHint", StageNoClearHintPropertyInfo), '("offscreen", StageOffscreenPropertyInfo), '("offscreenRedirect", Clutter.Actor.ActorOffscreenRedirectPropertyInfo), '("opacity", Clutter.Actor.ActorOpacityPropertyInfo), '("perspective", StagePerspectivePropertyInfo), '("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), '("title", StageTitlePropertyInfo), '("transform", Clutter.Actor.ActorTransformPropertyInfo), '("transformSet", Clutter.Actor.ActorTransformSetPropertyInfo), '("translationX", Clutter.Actor.ActorTranslationXPropertyInfo), '("translationY", Clutter.Actor.ActorTranslationYPropertyInfo), '("translationZ", Clutter.Actor.ActorTranslationZPropertyInfo), '("useAlpha", StageUseAlphaPropertyInfo), '("useFog", StageUseFogPropertyInfo), '("userResizable", StageUserResizablePropertyInfo), '("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)
stageAcceptFocus :: AttrLabelProxy "acceptFocus"
stageAcceptFocus = AttrLabelProxy

stageColor :: AttrLabelProxy "color"
stageColor = AttrLabelProxy

stageCursorVisible :: AttrLabelProxy "cursorVisible"
stageCursorVisible = AttrLabelProxy

stageFog :: AttrLabelProxy "fog"
stageFog = AttrLabelProxy

stageFullscreenSet :: AttrLabelProxy "fullscreenSet"
stageFullscreenSet = AttrLabelProxy

stageKeyFocus :: AttrLabelProxy "keyFocus"
stageKeyFocus = AttrLabelProxy

stageNoClearHint :: AttrLabelProxy "noClearHint"
stageNoClearHint = AttrLabelProxy

stageOffscreen :: AttrLabelProxy "offscreen"
stageOffscreen = AttrLabelProxy

stagePerspective :: AttrLabelProxy "perspective"
stagePerspective = AttrLabelProxy

stageTitle :: AttrLabelProxy "title"
stageTitle = AttrLabelProxy

stageUseAlpha :: AttrLabelProxy "useAlpha"
stageUseAlpha = AttrLabelProxy

stageUseFog :: AttrLabelProxy "useFog"
stageUseFog = AttrLabelProxy

stageUserResizable :: AttrLabelProxy "userResizable"
stageUserResizable = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Stage = StageSignalList
type StageSignalList = ('[ '("activate", StageActivateSignalInfo), '("actorAdded", Clutter.Container.ContainerActorAddedSignalInfo), '("actorRemoved", Clutter.Container.ContainerActorRemovedSignalInfo), '("afterPaint", StageAfterPaintSignalInfo), '("allocationChanged", Clutter.Actor.ActorAllocationChangedSignalInfo), '("buttonPressEvent", Clutter.Actor.ActorButtonPressEventSignalInfo), '("buttonReleaseEvent", Clutter.Actor.ActorButtonReleaseEventSignalInfo), '("capturedEvent", Clutter.Actor.ActorCapturedEventSignalInfo), '("childNotify", Clutter.Container.ContainerChildNotifySignalInfo), '("deactivate", StageDeactivateSignalInfo), '("deleteEvent", StageDeleteEventSignalInfo), '("destroy", Clutter.Actor.ActorDestroySignalInfo), '("enterEvent", Clutter.Actor.ActorEnterEventSignalInfo), '("event", Clutter.Actor.ActorEventSignalInfo), '("fullscreen", StageFullscreenSignalInfo), '("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), '("unfullscreen", StageUnfullscreenSignalInfo), '("unrealize", Clutter.Actor.ActorUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "clutter_stage_new" clutter_stage_new :: 
    IO (Ptr Stage)

-- | Creates a new, non-default stage. A non-default stage is a new
-- top-level actor which can be used as another container. It works
-- exactly like the default stage, but while 'GI.Clutter.Objects.Stage.stageGetDefault'
-- will always return the same instance, you will have to keep a pointer
-- to any t'GI.Clutter.Objects.Stage.Stage' returned by 'GI.Clutter.Objects.Stage.stageNew'.
-- 
-- The ability to support multiple stages depends on the current
-- backend. Use 'GI.Clutter.Functions.featureAvailable' and
-- 'GI.Clutter.Flags.FeatureFlagsStageMultiple' to check at runtime whether a
-- backend supports multiple stages.
-- 
-- /Since: 0.8/
stageNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Stage
    -- ^ __Returns:__ a new stage, or 'P.Nothing' if the default backend does
    --   not support multiple stages. Use 'GI.Clutter.Objects.Actor.actorDestroy' to
    --   programmatically close the returned stage.
stageNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Stage
stageNew  = IO Stage -> m Stage
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Stage -> m Stage) -> IO Stage -> m Stage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
result <- IO (Ptr Stage)
clutter_stage_new
    Text -> Ptr Stage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stageNew" Ptr Stage
result
    Stage
result' <- ((ManagedPtr Stage -> Stage) -> Ptr Stage -> IO Stage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Stage -> Stage
Stage) Ptr Stage
result
    Stage -> IO Stage
forall (m :: * -> *) a. Monad m => a -> m a
return Stage
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Stage::ensure_current
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_ensure_current" clutter_stage_ensure_current :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO ()

-- | This function essentially makes sure the right GL context is
-- current for the passed stage. It is not intended to
-- be used by applications.
-- 
-- /Since: 0.8/
stageEnsureCurrent ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: the t'GI.Clutter.Objects.Stage.Stage'
    -> m ()
stageEnsureCurrent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m ()
stageEnsureCurrent a
stage = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Stage -> IO ()
clutter_stage_ensure_current Ptr Stage
stage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageEnsureCurrentMethodInfo
instance (signature ~ (m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageEnsureCurrentMethodInfo a signature where
    overloadedMethod = stageEnsureCurrent

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


#endif

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

foreign import ccall "clutter_stage_ensure_redraw" clutter_stage_ensure_redraw :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO ()

-- | Ensures that /@stage@/ is redrawn
-- 
-- This function should not be called by applications: it is
-- used when embedding a t'GI.Clutter.Objects.Stage.Stage' into a toolkit with
-- another windowing system, like GTK+.
-- 
-- /Since: 1.0/
stageEnsureRedraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m ()
stageEnsureRedraw :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m ()
stageEnsureRedraw a
stage = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Stage -> IO ()
clutter_stage_ensure_redraw Ptr Stage
stage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageEnsureRedrawMethodInfo
instance (signature ~ (m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageEnsureRedrawMethodInfo a signature where
    overloadedMethod = stageEnsureRedraw

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


#endif

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

foreign import ccall "clutter_stage_ensure_viewport" clutter_stage_ensure_viewport :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO ()

-- | Ensures that the GL viewport is updated with the current
-- stage window size.
-- 
-- This function will queue a redraw of /@stage@/.
-- 
-- This function should not be called by applications; it is used
-- when embedding a t'GI.Clutter.Objects.Stage.Stage' into a toolkit with another
-- windowing system, like GTK+.
-- 
-- /Since: 1.0/
stageEnsureViewport ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m ()
stageEnsureViewport :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m ()
stageEnsureViewport a
stage = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Stage -> IO ()
clutter_stage_ensure_viewport Ptr Stage
stage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageEnsureViewportMethodInfo
instance (signature ~ (m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageEnsureViewportMethodInfo a signature where
    overloadedMethod = stageEnsureViewport

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


#endif

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

foreign import ccall "clutter_stage_event" clutter_stage_event :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Clutter.Event.Event ->              -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CInt

-- | This function is used to emit an event on the main stage.
-- 
-- You should rarely need to use this function, except for
-- synthetised events.
-- 
-- /Since: 0.4/
stageEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Clutter.Event.Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Bool
    -- ^ __Returns:__ the return value from the signal emission
stageEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Event -> m Bool
stageEvent a
stage Event
event = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
    CInt
result <- Ptr Stage -> Ptr Event -> IO CInt
clutter_stage_event Ptr Stage
stage' Ptr Event
event'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageEventMethodInfo
instance (signature ~ (Clutter.Event.Event -> m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageEventMethodInfo a signature where
    overloadedMethod = stageEvent

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


#endif

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

foreign import ccall "clutter_stage_get_accept_focus" clutter_stage_get_accept_focus :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

-- | Retrieves the value set with 'GI.Clutter.Objects.Stage.stageSetAcceptFocus'.
-- 
-- /Since: 1.6/
stageGetAcceptFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Stage.Stage' should accept focus, and 'P.False'
    --   otherwise
stageGetAcceptFocus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageGetAcceptFocus a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_get_accept_focus Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageGetAcceptFocusMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageGetAcceptFocusMethodInfo a signature where
    overloadedMethod = stageGetAcceptFocus

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


#endif

-- method Stage::get_actor_at_pos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pick_mode"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PickMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "how the scene graph should be painted"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "X coordinate to check"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Y coordinate to check"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_get_actor_at_pos" clutter_stage_get_actor_at_pos :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CUInt ->                                -- pick_mode : TInterface (Name {namespace = "Clutter", name = "PickMode"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    IO (Ptr Clutter.Actor.Actor)

-- | Checks the scene at the coordinates /@x@/ and /@y@/ and returns a pointer
-- to the t'GI.Clutter.Objects.Actor.Actor' at those coordinates.
-- 
-- By using /@pickMode@/ it is possible to control which actors will be
-- painted and thus available.
stageGetActorAtPos ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Clutter.Enums.PickMode
    -- ^ /@pickMode@/: how the scene graph should be painted
    -> Int32
    -- ^ /@x@/: X coordinate to check
    -> Int32
    -- ^ /@y@/: Y coordinate to check
    -> m Clutter.Actor.Actor
    -- ^ __Returns:__ the actor at the specified coordinates,
    --   if any
stageGetActorAtPos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> PickMode -> Int32 -> Int32 -> m Actor
stageGetActorAtPos a
stage PickMode
pickMode Int32
x Int32
y = IO Actor -> m Actor
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let pickMode' :: CUInt
pickMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PickMode -> Int) -> PickMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PickMode -> Int
forall a. Enum a => a -> Int
fromEnum) PickMode
pickMode
    Ptr Actor
result <- Ptr Stage -> CUInt -> Int32 -> Int32 -> IO (Ptr Actor)
clutter_stage_get_actor_at_pos Ptr Stage
stage' CUInt
pickMode' Int32
x Int32
y
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stageGetActorAtPos" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Clutter.Actor.Actor) Ptr Actor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Actor -> IO Actor
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
data StageGetActorAtPosMethodInfo
instance (signature ~ (Clutter.Enums.PickMode -> Int32 -> Int32 -> m Clutter.Actor.Actor), MonadIO m, IsStage a) => O.OverloadedMethod StageGetActorAtPosMethodInfo a signature where
    overloadedMethod = stageGetActorAtPos

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


#endif

-- method Stage::get_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterStage" , 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_stage_get_color" clutter_stage_get_color :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO ()

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

#if defined(ENABLE_OVERLOADING)
data StageGetColorMethodInfo
instance (signature ~ (m (Clutter.Color.Color)), MonadIO m, IsStage a) => O.OverloadedMethod StageGetColorMethodInfo a signature where
    overloadedMethod = stageGetColor

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


#endif

-- method Stage::get_fog
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fog"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Fog" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a #ClutterFog structure"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_get_fog" clutter_stage_get_fog :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Clutter.Fog.Fog ->                  -- fog : TInterface (Name {namespace = "Clutter", name = "Fog"})
    IO ()

{-# DEPRECATED stageGetFog ["(Since version 1.10)","This function will always return the default","  values of t'GI.Clutter.Structs.Fog.Fog'"] #-}
-- | Retrieves the current depth cueing settings from the stage.
-- 
-- /Since: 0.6/
stageGetFog ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: the t'GI.Clutter.Objects.Stage.Stage'
    -> m (Clutter.Fog.Fog)
stageGetFog :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Fog
stageGetFog a
stage = IO Fog -> m Fog
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Fog -> m Fog) -> IO Fog -> m Fog
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Fog
fog <- Int -> IO (Ptr Fog)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
8 :: IO (Ptr Clutter.Fog.Fog)
    Ptr Stage -> Ptr Fog -> IO ()
clutter_stage_get_fog Ptr Stage
stage' Ptr Fog
fog
    Fog
fog' <- ((ManagedPtr Fog -> Fog) -> Ptr Fog -> IO Fog
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Fog -> Fog
Clutter.Fog.Fog) Ptr Fog
fog
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Fog -> IO Fog
forall (m :: * -> *) a. Monad m => a -> m a
return Fog
fog'

#if defined(ENABLE_OVERLOADING)
data StageGetFogMethodInfo
instance (signature ~ (m (Clutter.Fog.Fog)), MonadIO m, IsStage a) => O.OverloadedMethod StageGetFogMethodInfo a signature where
    overloadedMethod = stageGetFog

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


#endif

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

foreign import ccall "clutter_stage_get_fullscreen" clutter_stage_get_fullscreen :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

-- | Retrieves whether the stage is full screen or not
-- 
-- /Since: 1.0/
stageGetFullscreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the stage is full screen
stageGetFullscreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageGetFullscreen a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_get_fullscreen Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageGetFullscreenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageGetFullscreenMethodInfo a signature where
    overloadedMethod = stageGetFullscreen

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


#endif

-- method Stage::get_key_focus
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_get_key_focus" clutter_stage_get_key_focus :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO (Ptr Clutter.Actor.Actor)

-- | Retrieves the actor that is currently under key focus.
-- 
-- /Since: 0.6/
stageGetKeyFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: the t'GI.Clutter.Objects.Stage.Stage'
    -> m Clutter.Actor.Actor
    -- ^ __Returns:__ the actor with key focus, or the stage
stageGetKeyFocus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Actor
stageGetKeyFocus a
stage = IO Actor -> m Actor
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Actor
result <- Ptr Stage -> IO (Ptr Actor)
clutter_stage_get_key_focus Ptr Stage
stage'
    Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stageGetKeyFocus" Ptr Actor
result
    Actor
result' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Clutter.Actor.Actor) Ptr Actor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Actor -> IO Actor
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'

#if defined(ENABLE_OVERLOADING)
data StageGetKeyFocusMethodInfo
instance (signature ~ (m Clutter.Actor.Actor), MonadIO m, IsStage a) => O.OverloadedMethod StageGetKeyFocusMethodInfo a signature where
    overloadedMethod = stageGetKeyFocus

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


#endif

-- method Stage::get_minimum_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the minimum width, in pixels,\n  or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the minimum height, in pixels,\n  or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_get_minimum_size" clutter_stage_get_minimum_size :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Word32 ->                           -- width : TBasicType TUInt
    Ptr Word32 ->                           -- height : TBasicType TUInt
    IO ()

-- | Retrieves the minimum size for a stage window as set using
-- 'GI.Clutter.Objects.Stage.stageSetMinimumSize'.
-- 
-- The returned size may not correspond to the actual minimum size and
-- it is specific to the t'GI.Clutter.Objects.Stage.Stage' implementation inside the
-- Clutter backend
-- 
-- /Since: 1.2/
stageGetMinimumSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m ((Word32, Word32))
stageGetMinimumSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m (Word32, Word32)
stageGetMinimumSize a
stage = IO (Word32, Word32) -> m (Word32, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word32, Word32) -> m (Word32, Word32))
-> IO (Word32, Word32) -> m (Word32, Word32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Word32
width <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr Word32
height <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr Stage -> Ptr Word32 -> Ptr Word32 -> IO ()
clutter_stage_get_minimum_size Ptr Stage
stage' Ptr Word32
width Ptr Word32
height
    Word32
width' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
width
    Word32
height' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
width
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
height
    (Word32, Word32) -> IO (Word32, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32
width', Word32
height')

#if defined(ENABLE_OVERLOADING)
data StageGetMinimumSizeMethodInfo
instance (signature ~ (m ((Word32, Word32))), MonadIO m, IsStage a) => O.OverloadedMethod StageGetMinimumSizeMethodInfo a signature where
    overloadedMethod = stageGetMinimumSize

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


#endif

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

foreign import ccall "clutter_stage_get_motion_events_enabled" clutter_stage_get_motion_events_enabled :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

-- | Retrieves the value set using 'GI.Clutter.Objects.Stage.stageSetMotionEventsEnabled'.
-- 
-- /Since: 1.8/
stageGetMotionEventsEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the per-actor motion event delivery is enabled
    --   and 'P.False' otherwise
stageGetMotionEventsEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageGetMotionEventsEnabled a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_get_motion_events_enabled Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageGetMotionEventsEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageGetMotionEventsEnabledMethodInfo a signature where
    overloadedMethod = stageGetMotionEventsEnabled

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


#endif

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

foreign import ccall "clutter_stage_get_no_clear_hint" clutter_stage_get_no_clear_hint :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

-- | Retrieves the hint set with 'GI.Clutter.Objects.Stage.stageSetNoClearHint'
-- 
-- /Since: 1.4/
stageGetNoClearHint ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the stage should not clear itself on every paint
    --   cycle, and 'P.False' otherwise
stageGetNoClearHint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageGetNoClearHint a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_get_no_clear_hint Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageGetNoClearHintMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageGetNoClearHintMethodInfo a signature where
    overloadedMethod = stageGetNoClearHint

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


#endif

-- method Stage::get_perspective
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "perspective"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Perspective" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a\n  #ClutterPerspective"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_get_perspective" clutter_stage_get_perspective :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Clutter.Perspective.Perspective ->  -- perspective : TInterface (Name {namespace = "Clutter", name = "Perspective"})
    IO ()

-- | Retrieves the stage perspective.
stageGetPerspective ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: A t'GI.Clutter.Objects.Stage.Stage'
    -> m (Clutter.Perspective.Perspective)
stageGetPerspective :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Perspective
stageGetPerspective a
stage = IO Perspective -> m Perspective
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Perspective -> m Perspective)
-> IO Perspective -> m Perspective
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Perspective
perspective <- Int -> IO (Ptr Perspective)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.Perspective.Perspective)
    Ptr Stage -> Ptr Perspective -> IO ()
clutter_stage_get_perspective Ptr Stage
stage' Ptr Perspective
perspective
    Perspective
perspective' <- ((ManagedPtr Perspective -> Perspective)
-> Ptr Perspective -> IO Perspective
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Perspective -> Perspective
Clutter.Perspective.Perspective) Ptr Perspective
perspective
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Perspective -> IO Perspective
forall (m :: * -> *) a. Monad m => a -> m a
return Perspective
perspective'

#if defined(ENABLE_OVERLOADING)
data StageGetPerspectiveMethodInfo
instance (signature ~ (m (Clutter.Perspective.Perspective)), MonadIO m, IsStage a) => O.OverloadedMethod StageGetPerspectiveMethodInfo a signature where
    overloadedMethod = stageGetPerspective

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


#endif

-- method Stage::get_redraw_clip_bounds
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clip"
--           , argType =
--               TInterface Name { namespace = "cairo" , name = "RectangleInt" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Return location for the clip bounds"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_get_redraw_clip_bounds" clutter_stage_get_redraw_clip_bounds :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Cairo.RectangleInt.RectangleInt ->  -- clip : TInterface (Name {namespace = "cairo", name = "RectangleInt"})
    IO ()

-- | Gets the bounds of the current redraw for /@stage@/ in stage pixel
-- coordinates. E.g., if only a single actor has queued a redraw then
-- Clutter may redraw the stage with a clip so that it doesn\'t have to
-- paint every pixel in the stage. This function would then return the
-- bounds of that clip. An application can use this information to
-- avoid some extra work if it knows that some regions of the stage
-- aren\'t going to be painted. This should only be called while the
-- stage is being painted. If there is no current redraw clip then
-- this function will set /@clip@/ to the full extents of the stage.
-- 
-- /Since: 1.8/
stageGetRedrawClipBounds ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: A t'GI.Clutter.Objects.Stage.Stage'
    -> m (Cairo.RectangleInt.RectangleInt)
stageGetRedrawClipBounds :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m RectangleInt
stageGetRedrawClipBounds a
stage = IO RectangleInt -> m RectangleInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RectangleInt -> m RectangleInt)
-> IO RectangleInt -> m RectangleInt
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr RectangleInt
clip <- Int -> IO (Ptr RectangleInt)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Cairo.RectangleInt.RectangleInt)
    Ptr Stage -> Ptr RectangleInt -> IO ()
clutter_stage_get_redraw_clip_bounds Ptr Stage
stage' Ptr RectangleInt
clip
    RectangleInt
clip' <- ((ManagedPtr RectangleInt -> RectangleInt)
-> Ptr RectangleInt -> IO RectangleInt
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RectangleInt -> RectangleInt
Cairo.RectangleInt.RectangleInt) Ptr RectangleInt
clip
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    RectangleInt -> IO RectangleInt
forall (m :: * -> *) a. Monad m => a -> m a
return RectangleInt
clip'

#if defined(ENABLE_OVERLOADING)
data StageGetRedrawClipBoundsMethodInfo
instance (signature ~ (m (Cairo.RectangleInt.RectangleInt)), MonadIO m, IsStage a) => O.OverloadedMethod StageGetRedrawClipBoundsMethodInfo a signature where
    overloadedMethod = stageGetRedrawClipBounds

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


#endif

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

foreign import ccall "clutter_stage_get_throttle_motion_events" clutter_stage_get_throttle_motion_events :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

-- | Retrieves the value set with 'GI.Clutter.Objects.Stage.stageSetThrottleMotionEvents'
-- 
-- /Since: 1.0/
stageGetThrottleMotionEvents ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the motion events are being throttled,
    --   and 'P.False' otherwise
stageGetThrottleMotionEvents :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageGetThrottleMotionEvents a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_get_throttle_motion_events Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageGetThrottleMotionEventsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageGetThrottleMotionEventsMethodInfo a signature where
    overloadedMethod = stageGetThrottleMotionEvents

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


#endif

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

foreign import ccall "clutter_stage_get_title" clutter_stage_get_title :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CString

-- | Gets the stage title.
-- 
-- /Since: 0.4/
stageGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: A t'GI.Clutter.Objects.Stage.Stage'
    -> m T.Text
    -- ^ __Returns:__ pointer to the title string for the stage. The
    -- returned string is owned by the actor and should not
    -- be modified or freed.
stageGetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Text
stageGetTitle a
stage = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CString
result <- Ptr Stage -> IO CString
clutter_stage_get_title Ptr Stage
stage'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stageGetTitle" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data StageGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsStage a) => O.OverloadedMethod StageGetTitleMethodInfo a signature where
    overloadedMethod = stageGetTitle

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


#endif

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

foreign import ccall "clutter_stage_get_use_alpha" clutter_stage_get_use_alpha :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

-- | Retrieves the value set using 'GI.Clutter.Objects.Stage.stageSetUseAlpha'
-- 
-- /Since: 1.2/
stageGetUseAlpha ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the stage should honour the opacity and the
    --   alpha channel of the stage color
stageGetUseAlpha :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageGetUseAlpha a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_get_use_alpha Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageGetUseAlphaMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageGetUseAlphaMethodInfo a signature where
    overloadedMethod = stageGetUseAlpha

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


#endif

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

foreign import ccall "clutter_stage_get_use_fog" clutter_stage_get_use_fog :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

{-# DEPRECATED stageGetUseFog ["(Since version 1.10)","This function will always return 'P.False'"] #-}
-- | Gets whether the depth cueing effect is enabled on /@stage@/.
-- 
-- /Since: 0.6/
stageGetUseFog ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: the t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the depth cueing effect is enabled
stageGetUseFog :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageGetUseFog a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_get_use_fog Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageGetUseFogMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageGetUseFogMethodInfo a signature where
    overloadedMethod = stageGetUseFog

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


#endif

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

foreign import ccall "clutter_stage_get_user_resizable" clutter_stage_get_user_resizable :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

-- | Retrieves the value set with 'GI.Clutter.Objects.Stage.stageSetUserResizable'.
-- 
-- /Since: 0.4/
stageGetUserResizable ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the stage is resizable by the user.
stageGetUserResizable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageGetUserResizable a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_get_user_resizable Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageGetUserResizableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageGetUserResizableMethodInfo a signature where
    overloadedMethod = stageGetUserResizable

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


#endif

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

foreign import ccall "clutter_stage_hide_cursor" clutter_stage_hide_cursor :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO ()

-- | Makes the cursor invisible on the stage window
-- 
-- /Since: 0.4/
stageHideCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m ()
stageHideCursor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m ()
stageHideCursor a
stage = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Stage -> IO ()
clutter_stage_hide_cursor Ptr Stage
stage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageHideCursorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageHideCursorMethodInfo a signature where
    overloadedMethod = stageHideCursor

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


#endif

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

foreign import ccall "clutter_stage_is_default" clutter_stage_is_default :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO CInt

{-# DEPRECATED stageIsDefault ["(Since version 1.10)","Track the stage pointer inside your application","  code, or use 'GI.Clutter.Objects.Actor.actorGetStage' to retrieve the stage for","  a given actor."] #-}
-- | Checks if /@stage@/ is the default stage, or an instance created using
-- 'GI.Clutter.Objects.Stage.stageNew' but internally using the same implementation.
-- 
-- /Since: 0.8/
stageIsDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the passed stage is the default one
stageIsDefault :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m Bool
stageIsDefault a
stage = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CInt
result <- Ptr Stage -> IO CInt
clutter_stage_is_default Ptr Stage
stage'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StageIsDefaultMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsStage a) => O.OverloadedMethod StageIsDefaultMethodInfo a signature where
    overloadedMethod = stageIsDefault

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


#endif

-- method Stage::queue_redraw
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_queue_redraw" clutter_stage_queue_redraw :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO ()

{-# DEPRECATED stageQueueRedraw ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorQueueRedraw' instead."] #-}
-- | Queues a redraw for the passed stage.
-- 
-- Applications should call 'GI.Clutter.Objects.Actor.actorQueueRedraw' and not
-- this function.
-- 
-- /Since: 0.8/
stageQueueRedraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: the t'GI.Clutter.Objects.Stage.Stage'
    -> m ()
stageQueueRedraw :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m ()
stageQueueRedraw a
stage = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Stage -> IO ()
clutter_stage_queue_redraw Ptr Stage
stage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageQueueRedrawMethodInfo
instance (signature ~ (m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageQueueRedrawMethodInfo a signature where
    overloadedMethod = stageQueueRedraw

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


#endif

-- XXX Could not generate method Stage::read_pixels
{-  Bad introspection data: `TCArray False (-1) (-1) (TBasicType TUInt8)' is an array type, but contains no length information,
    so it cannot be unpacked.
-}
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data StageReadPixelsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "readPixels" Stage) => O.OverloadedMethod StageReadPixelsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "readPixels" Stage) => O.OverloadedMethodInfo StageReadPixelsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Stage::set_accept_focus
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "accept_focus"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to accept focus on show"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_accept_focus" clutter_stage_set_accept_focus :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CInt ->                                 -- accept_focus : TBasicType TBoolean
    IO ()

-- | Sets whether the /@stage@/ should accept the key focus when shown.
-- 
-- This function should be called before showing /@stage@/ using
-- 'GI.Clutter.Objects.Actor.actorShow'.
-- 
-- /Since: 1.6/
stageSetAcceptFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Bool
    -- ^ /@acceptFocus@/: 'P.True' to accept focus on show
    -> m ()
stageSetAcceptFocus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Bool -> m ()
stageSetAcceptFocus a
stage Bool
acceptFocus = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let acceptFocus' :: CInt
acceptFocus' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
acceptFocus
    Ptr Stage -> CInt -> IO ()
clutter_stage_set_accept_focus Ptr Stage
stage' CInt
acceptFocus'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetAcceptFocusMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetAcceptFocusMethodInfo a signature where
    overloadedMethod = stageSetAcceptFocus

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


#endif

-- method Stage::set_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterStage" , 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_stage_set_color" clutter_stage_set_color :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO ()

{-# DEPRECATED stageSetColor ["(Since version 1.10)","Use 'GI.Clutter.Objects.Actor.actorSetBackgroundColor' instead."] #-}
-- | Sets the stage color.
stageSetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: A t'GI.Clutter.Objects.Stage.Stage'
    -> Clutter.Color.Color
    -- ^ /@color@/: A t'GI.Clutter.Structs.Color.Color'
    -> m ()
stageSetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Color -> m ()
stageSetColor a
stage 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
    Ptr Stage -> Ptr Color -> IO ()
clutter_stage_set_color Ptr Stage
stage' Ptr Color
color'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    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 StageSetColorMethodInfo
instance (signature ~ (Clutter.Color.Color -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetColorMethodInfo a signature where
    overloadedMethod = stageSetColor

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


#endif

-- method Stage::set_fog
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fog"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Fog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterFog structure"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_fog" clutter_stage_set_fog :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Clutter.Fog.Fog ->                  -- fog : TInterface (Name {namespace = "Clutter", name = "Fog"})
    IO ()

{-# DEPRECATED stageSetFog ["(Since version 1.10)","Fog settings are ignored."] #-}
-- | Sets the fog (also known as \"depth cueing\") settings for the /@stage@/.
-- 
-- A t'GI.Clutter.Objects.Stage.Stage' will only use a linear fog progression, which
-- depends solely on the distance from the viewer. The 'GI.Cogl.Functions.setFog'
-- function in COGL exposes more of the underlying implementation,
-- and allows changing the for progression function. It can be directly
-- used by disabling the t'GI.Clutter.Objects.Stage.Stage':@/use-fog/@ property and connecting
-- a signal handler to the [paint]("GI.Clutter.Objects.Actor#g:signal:paint") signal on the /@stage@/,
-- like:
-- 
-- >
-- >  clutter_stage_set_use_fog (stage, FALSE);
-- >  g_signal_connect (stage, "paint", G_CALLBACK (on_stage_paint), NULL);
-- 
-- 
-- The paint signal handler will call 'GI.Cogl.Functions.setFog' with the
-- desired settings:
-- 
-- >
-- >  static void
-- >  on_stage_paint (ClutterActor *actor)
-- >  {
-- >    ClutterColor stage_color = { 0, };
-- >    CoglColor fog_color = { 0, };
-- >
-- >    // set the fog color to the stage background color
-- >    clutter_stage_get_color (CLUTTER_STAGE (actor), &stage_color);
-- >    cogl_color_init_from_4ub (&fog_color,
-- >                              stage_color.red,
-- >                              stage_color.green,
-- >                              stage_color.blue,
-- >                              stage_color.alpha);
-- >
-- >    // enable fog //
-- >    cogl_set_fog (&fog_color,
-- >                  COGL_FOG_MODE_EXPONENTIAL, // mode
-- >                  0.5,                       // density
-- >                  5.0, 30.0);                // z_near and z_far
-- >  }
-- 
-- 
-- The fogging functions only work correctly when the visible actors use
-- unmultiplied alpha colors. By default Cogl will premultiply textures and
-- 'GI.Cogl.Functions.setSourceColor' will premultiply colors, so unless you explicitly
-- load your textures requesting an unmultiplied internal format and use
-- 'GI.Cogl.Structs.Material.materialSetColor' you can only use fogging with fully opaque actors.
-- Support for premultiplied colors will improve in the future when we can
-- depend on fragment shaders.
-- 
-- /Since: 0.6/
stageSetFog ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: the t'GI.Clutter.Objects.Stage.Stage'
    -> Clutter.Fog.Fog
    -- ^ /@fog@/: a t'GI.Clutter.Structs.Fog.Fog' structure
    -> m ()
stageSetFog :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Fog -> m ()
stageSetFog a
stage Fog
fog = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Fog
fog' <- Fog -> IO (Ptr Fog)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Fog
fog
    Ptr Stage -> Ptr Fog -> IO ()
clutter_stage_set_fog Ptr Stage
stage' Ptr Fog
fog'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Fog -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Fog
fog
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetFogMethodInfo
instance (signature ~ (Clutter.Fog.Fog -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetFogMethodInfo a signature where
    overloadedMethod = stageSetFog

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


#endif

-- method Stage::set_fullscreen
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fullscreen"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to to set the stage fullscreen"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_fullscreen" clutter_stage_set_fullscreen :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CInt ->                                 -- fullscreen : TBasicType TBoolean
    IO ()

-- | Asks to place the stage window in the fullscreen or unfullscreen
-- states.
-- 
--  ( Note that you shouldn\'t assume the window is definitely full screen
-- afterward, because other entities (e.g. the user or window manager)
-- could unfullscreen it again, and not all window managers honor
-- requests to fullscreen windows.
-- 
-- If you want to receive notification of the fullscreen state you
-- should either use the [fullscreen]("GI.Clutter.Objects.Stage#g:signal:fullscreen") and
-- [unfullscreen]("GI.Clutter.Objects.Stage#g:signal:unfullscreen") signals, or use the notify signal
-- for the t'GI.Clutter.Objects.Stage.Stage':@/fullscreen-set/@ property
-- 
-- /Since: 1.0/
stageSetFullscreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Bool
    -- ^ /@fullscreen@/: 'P.True' to to set the stage fullscreen
    -> m ()
stageSetFullscreen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Bool -> m ()
stageSetFullscreen a
stage Bool
fullscreen = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let fullscreen' :: CInt
fullscreen' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
fullscreen
    Ptr Stage -> CInt -> IO ()
clutter_stage_set_fullscreen Ptr Stage
stage' CInt
fullscreen'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetFullscreenMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetFullscreenMethodInfo a signature where
    overloadedMethod = stageSetFullscreen

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


#endif

-- method Stage::set_key_focus
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the actor to set key focus to, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_key_focus" clutter_stage_set_key_focus :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Clutter.Actor.Actor ->              -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Sets the key focus on /@actor@/. An actor with key focus will receive
-- all the key events. If /@actor@/ is 'P.Nothing', the stage will receive
-- focus.
-- 
-- /Since: 0.6/
stageSetKeyFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a, Clutter.Actor.IsActor b) =>
    a
    -- ^ /@stage@/: the t'GI.Clutter.Objects.Stage.Stage'
    -> Maybe (b)
    -- ^ /@actor@/: the actor to set key focus to, or 'P.Nothing'
    -> m ()
stageSetKeyFocus :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsStage a, IsActor b) =>
a -> Maybe b -> m ()
stageSetKeyFocus a
stage Maybe b
actor = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Actor
maybeActor <- case Maybe b
actor of
        Maybe b
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
        Just b
jActor -> do
            Ptr Actor
jActor' <- b -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jActor
            Ptr Actor -> IO (Ptr Actor)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jActor'
    Ptr Stage -> Ptr Actor -> IO ()
clutter_stage_set_key_focus Ptr Stage
stage' Ptr Actor
maybeActor
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
actor b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetKeyFocusMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsStage a, Clutter.Actor.IsActor b) => O.OverloadedMethod StageSetKeyFocusMethodInfo a signature where
    overloadedMethod = stageSetKeyFocus

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


#endif

-- method Stage::set_minimum_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , 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 "width, in pixels" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "height, in pixels" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_minimum_size" clutter_stage_set_minimum_size :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Word32 ->                               -- width : TBasicType TUInt
    Word32 ->                               -- height : TBasicType TUInt
    IO ()

-- | Sets the minimum size for a stage window, if the default backend
-- uses t'GI.Clutter.Objects.Stage.Stage' inside a window
-- 
-- This is a convenience function, and it is equivalent to setting the
-- t'GI.Clutter.Objects.Actor.Actor':@/min-width/@ and t'GI.Clutter.Objects.Actor.Actor':@/min-height/@ on /@stage@/
-- 
-- If the current size of /@stage@/ is smaller than the minimum size, the
-- /@stage@/ will be resized to the new /@width@/ and /@height@/
-- 
-- This function has no effect if /@stage@/ is fullscreen
-- 
-- /Since: 1.2/
stageSetMinimumSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Word32
    -- ^ /@width@/: width, in pixels
    -> Word32
    -- ^ /@height@/: height, in pixels
    -> m ()
stageSetMinimumSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Word32 -> Word32 -> m ()
stageSetMinimumSize a
stage Word32
width Word32
height = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Stage -> Word32 -> Word32 -> IO ()
clutter_stage_set_minimum_size Ptr Stage
stage' Word32
width Word32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetMinimumSizeMethodInfo
instance (signature ~ (Word32 -> Word32 -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetMinimumSizeMethodInfo a signature where
    overloadedMethod = stageSetMinimumSize

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


#endif

-- method Stage::set_motion_events_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%TRUE to enable the motion events delivery, and %FALSE\n  otherwise"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_motion_events_enabled" clutter_stage_set_motion_events_enabled :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | Sets whether per-actor motion events (and relative crossing
-- events) should be disabled or not.
-- 
-- The default is 'P.True'.
-- 
-- If /@enable@/ is 'P.False' the following signals will not be emitted
-- by the actors children of /@stage@/:
-- 
--  - [motionEvent]("GI.Clutter.Objects.Actor#g:signal:motionEvent")
--  - [enterEvent]("GI.Clutter.Objects.Actor#g:signal:enterEvent")
--  - [leaveEvent]("GI.Clutter.Objects.Actor#g:signal:leaveEvent")
-- 
-- The events will still be delivered to the t'GI.Clutter.Objects.Stage.Stage'.
-- 
-- The main side effect of this function is that disabling the motion
-- events will disable picking to detect the t'GI.Clutter.Objects.Actor.Actor' underneath
-- the pointer for each motion event. This is useful, for instance,
-- when dragging a t'GI.Clutter.Objects.Actor.Actor' across the /@stage@/: the actor underneath
-- the pointer is not going to change, so it\'s meaningless to perform
-- a pick.
-- 
-- /Since: 1.8/
stageSetMotionEventsEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Bool
    -- ^ /@enabled@/: 'P.True' to enable the motion events delivery, and 'P.False'
    --   otherwise
    -> m ()
stageSetMotionEventsEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Bool -> m ()
stageSetMotionEventsEnabled a
stage Bool
enabled = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
    Ptr Stage -> CInt -> IO ()
clutter_stage_set_motion_events_enabled Ptr Stage
stage' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetMotionEventsEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetMotionEventsEnabledMethodInfo a signature where
    overloadedMethod = stageSetMotionEventsEnabled

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


#endif

-- method Stage::set_no_clear_hint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "no_clear"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%TRUE if the @stage should not clear itself on every\n  repaint cycle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_no_clear_hint" clutter_stage_set_no_clear_hint :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CInt ->                                 -- no_clear : TBasicType TBoolean
    IO ()

-- | Sets whether the /@stage@/ should clear itself at the beginning
-- of each paint cycle or not.
-- 
-- Clearing the t'GI.Clutter.Objects.Stage.Stage' can be a costly operation, especially
-- if the stage is always covered - for instance, in a full-screen
-- video player or in a game with a background texture.
-- 
-- This setting is a hint; Clutter might discard this hint
-- depending on its internal state.
-- 
-- If parts of the stage are visible and you disable clearing you
-- might end up with visual artifacts while painting the contents of
-- the stage.
-- 
-- /Since: 1.4/
stageSetNoClearHint ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Bool
    -- ^ /@noClear@/: 'P.True' if the /@stage@/ should not clear itself on every
    --   repaint cycle
    -> m ()
stageSetNoClearHint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Bool -> m ()
stageSetNoClearHint a
stage Bool
noClear = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let noClear' :: CInt
noClear' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
noClear
    Ptr Stage -> CInt -> IO ()
clutter_stage_set_no_clear_hint Ptr Stage
stage' CInt
noClear'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetNoClearHintMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetNoClearHintMethodInfo a signature where
    overloadedMethod = stageSetNoClearHint

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


#endif

-- method Stage::set_perspective
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "perspective"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Perspective" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPerspective"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_perspective" clutter_stage_set_perspective :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    Ptr Clutter.Perspective.Perspective ->  -- perspective : TInterface (Name {namespace = "Clutter", name = "Perspective"})
    IO ()

-- | Sets the stage perspective. Using this function is not recommended
-- because it will disable Clutter\'s attempts to generate an
-- appropriate perspective based on the size of the stage.
stageSetPerspective ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: A t'GI.Clutter.Objects.Stage.Stage'
    -> Clutter.Perspective.Perspective
    -- ^ /@perspective@/: A t'GI.Clutter.Structs.Perspective.Perspective'
    -> m ()
stageSetPerspective :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Perspective -> m ()
stageSetPerspective a
stage Perspective
perspective = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Perspective
perspective' <- Perspective -> IO (Ptr Perspective)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Perspective
perspective
    Ptr Stage -> Ptr Perspective -> IO ()
clutter_stage_set_perspective Ptr Stage
stage' Ptr Perspective
perspective'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    Perspective -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Perspective
perspective
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetPerspectiveMethodInfo
instance (signature ~ (Clutter.Perspective.Perspective -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetPerspectiveMethodInfo a signature where
    overloadedMethod = stageSetPerspective

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


#endif

-- method Stage::set_throttle_motion_events
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "throttle"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to throttle motion events"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_throttle_motion_events" clutter_stage_set_throttle_motion_events :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CInt ->                                 -- throttle : TBasicType TBoolean
    IO ()

-- | Sets whether motion events received between redraws should
-- be throttled or not. If motion events are throttled, those
-- events received by the windowing system between redraws will
-- be compressed so that only the last event will be propagated
-- to the /@stage@/ and its actors.
-- 
-- This function should only be used if you want to have all
-- the motion events delivered to your application code.
-- 
-- /Since: 1.0/
stageSetThrottleMotionEvents ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Bool
    -- ^ /@throttle@/: 'P.True' to throttle motion events
    -> m ()
stageSetThrottleMotionEvents :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Bool -> m ()
stageSetThrottleMotionEvents a
stage Bool
throttle = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let throttle' :: CInt
throttle' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
throttle
    Ptr Stage -> CInt -> IO ()
clutter_stage_set_throttle_motion_events Ptr Stage
stage' CInt
throttle'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetThrottleMotionEventsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetThrottleMotionEventsMethodInfo a signature where
    overloadedMethod = stageSetThrottleMotionEvents

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


#endif

-- method Stage::set_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "title"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A utf8 string for the stage windows title."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_title" clutter_stage_set_title :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CString ->                              -- title : TBasicType TUTF8
    IO ()

-- | Sets the stage title.
-- 
-- /Since: 0.4/
stageSetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: A t'GI.Clutter.Objects.Stage.Stage'
    -> T.Text
    -- ^ /@title@/: A utf8 string for the stage windows title.
    -> m ()
stageSetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Text -> m ()
stageSetTitle a
stage Text
title = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    CString
title' <- Text -> IO CString
textToCString Text
title
    Ptr Stage -> CString -> IO ()
clutter_stage_set_title Ptr Stage
stage' CString
title'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
title'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetTitleMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetTitleMethodInfo a signature where
    overloadedMethod = stageSetTitle

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


#endif

-- method Stage::set_use_alpha
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "use_alpha"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "whether the stage should honour the opacity or the\n  alpha channel of the stage color"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_use_alpha" clutter_stage_set_use_alpha :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CInt ->                                 -- use_alpha : TBasicType TBoolean
    IO ()

-- | Sets whether the /@stage@/ should honour the t'GI.Clutter.Objects.Actor.Actor':@/opacity/@ and
-- the alpha channel of the t'GI.Clutter.Objects.Stage.Stage':@/color/@
-- 
-- /Since: 1.2/
stageSetUseAlpha ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Bool
    -- ^ /@useAlpha@/: whether the stage should honour the opacity or the
    --   alpha channel of the stage color
    -> m ()
stageSetUseAlpha :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Bool -> m ()
stageSetUseAlpha a
stage Bool
useAlpha = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let useAlpha' :: CInt
useAlpha' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
useAlpha
    Ptr Stage -> CInt -> IO ()
clutter_stage_set_use_alpha Ptr Stage
stage' CInt
useAlpha'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetUseAlphaMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetUseAlphaMethodInfo a signature where
    overloadedMethod = stageSetUseAlpha

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


#endif

-- method Stage::set_use_fog
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fog"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE for enabling the depth cueing effect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_use_fog" clutter_stage_set_use_fog :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CInt ->                                 -- fog : TBasicType TBoolean
    IO ()

{-# DEPRECATED stageSetUseFog ["(Since version 1.10)","Calling this function produces no visible effect"] #-}
-- | Sets whether the depth cueing effect on the stage should be enabled
-- or not.
-- 
-- Depth cueing is a 3D effect that makes actors farther away from the
-- viewing point less opaque, by fading them with the stage color.
-- 
-- The parameters of the GL fog used can be changed using the
-- 'GI.Clutter.Objects.Stage.stageSetFog' function.
-- 
-- /Since: 0.6/
stageSetUseFog ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: the t'GI.Clutter.Objects.Stage.Stage'
    -> Bool
    -- ^ /@fog@/: 'P.True' for enabling the depth cueing effect
    -> m ()
stageSetUseFog :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Bool -> m ()
stageSetUseFog a
stage Bool
fog = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let fog' :: CInt
fog' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
fog
    Ptr Stage -> CInt -> IO ()
clutter_stage_set_use_fog Ptr Stage
stage' CInt
fog'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetUseFogMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetUseFogMethodInfo a signature where
    overloadedMethod = stageSetUseFog

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


#endif

-- method Stage::set_user_resizable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resizable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the stage should be user resizable."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_stage_set_user_resizable" clutter_stage_set_user_resizable :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    CInt ->                                 -- resizable : TBasicType TBoolean
    IO ()

-- | Sets if the stage is resizable by user interaction (e.g. via
-- window manager controls)
-- 
-- /Since: 0.4/
stageSetUserResizable ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> Bool
    -- ^ /@resizable@/: whether the stage should be user resizable.
    -> m ()
stageSetUserResizable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> Bool -> m ()
stageSetUserResizable a
stage Bool
resizable = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    let resizable' :: CInt
resizable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
resizable
    Ptr Stage -> CInt -> IO ()
clutter_stage_set_user_resizable Ptr Stage
stage' CInt
resizable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageSetUserResizableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageSetUserResizableMethodInfo a signature where
    overloadedMethod = stageSetUserResizable

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


#endif

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

foreign import ccall "clutter_stage_show_cursor" clutter_stage_show_cursor :: 
    Ptr Stage ->                            -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO ()

-- | Shows the cursor on the stage window
stageShowCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsStage a) =>
    a
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage'
    -> m ()
stageShowCursor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
a -> m ()
stageShowCursor a
stage = 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 Stage
stage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stage
    Ptr Stage -> IO ()
clutter_stage_show_cursor Ptr Stage
stage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stage
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StageShowCursorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsStage a) => O.OverloadedMethod StageShowCursorMethodInfo a signature where
    overloadedMethod = stageShowCursor

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


#endif

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

foreign import ccall "clutter_stage_get_default" clutter_stage_get_default :: 
    IO (Ptr Stage)

{-# DEPRECATED stageGetDefault ["(Since version 1.10)","Use 'GI.Clutter.Objects.Stage.stageNew' instead."] #-}
-- | Retrieves a t'GI.Clutter.Objects.Stage.Stage' singleton.
-- 
-- This function is not as useful as it sounds, and will most likely
-- by deprecated in the future. Application code should only create
-- a t'GI.Clutter.Objects.Stage.Stage' instance using 'GI.Clutter.Objects.Stage.stageNew', and manage the
-- lifetime of the stage manually.
-- 
-- The default stage singleton has a platform-specific behaviour: on
-- platforms without the 'GI.Clutter.Flags.FeatureFlagsStageMultiple' feature flag
-- set, the first t'GI.Clutter.Objects.Stage.Stage' instance will also be set to be the
-- default stage instance, and this function will always return a
-- pointer to it.
-- 
-- On platforms with the 'GI.Clutter.Flags.FeatureFlagsStageMultiple' feature flag
-- set, the default stage will be created by the first call to this
-- function, and every following call will return the same pointer to
-- it.
stageGetDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Stage
    -- ^ __Returns:__ the main
    --   t'GI.Clutter.Objects.Stage.Stage'. You should never destroy or unref the returned
    --   actor.
stageGetDefault :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Stage
stageGetDefault  = IO Stage -> m Stage
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Stage -> m Stage) -> IO Stage -> m Stage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Stage
result <- IO (Ptr Stage)
clutter_stage_get_default
    Text -> Ptr Stage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stageGetDefault" Ptr Stage
result
    Stage
result' <- ((ManagedPtr Stage -> Stage) -> Ptr Stage -> IO Stage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Stage -> Stage
Stage) Ptr Stage
result
    Stage -> IO Stage
forall (m :: * -> *) a. Monad m => a -> m a
return Stage
result'

#if defined(ENABLE_OVERLOADING)
#endif