{-# 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.Texture.Texture' 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.Texture
    ( 

-- * Exported types
    Texture(..)                             ,
    IsTexture                               ,
    toTexture                               ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addAction]("GI.Clutter.Objects.Actor#g:method:addAction"), [addActionWithName]("GI.Clutter.Objects.Actor#g:method:addActionWithName"), [addActor]("GI.Clutter.Interfaces.Container#g:method:addActor"), [addChild]("GI.Clutter.Objects.Actor#g:method:addChild"), [addConstraint]("GI.Clutter.Objects.Actor#g:method:addConstraint"), [addConstraintWithName]("GI.Clutter.Objects.Actor#g:method:addConstraintWithName"), [addEffect]("GI.Clutter.Objects.Actor#g:method:addEffect"), [addEffectWithName]("GI.Clutter.Objects.Actor#g:method:addEffectWithName"), [addTransition]("GI.Clutter.Objects.Actor#g:method:addTransition"), [allocate]("GI.Clutter.Objects.Actor#g:method:allocate"), [allocateAlignFill]("GI.Clutter.Objects.Actor#g:method:allocateAlignFill"), [allocateAvailableSize]("GI.Clutter.Objects.Actor#g:method:allocateAvailableSize"), [allocatePreferredSize]("GI.Clutter.Objects.Actor#g:method:allocatePreferredSize"), [animateProperty]("GI.Clutter.Interfaces.Animatable#g:method:animateProperty"), [animateWithAlphav]("GI.Clutter.Objects.Actor#g:method:animateWithAlphav"), [animateWithTimelinev]("GI.Clutter.Objects.Actor#g:method:animateWithTimelinev"), [animatev]("GI.Clutter.Objects.Actor#g:method:animatev"), [applyRelativeTransformToPoint]("GI.Clutter.Objects.Actor#g:method:applyRelativeTransformToPoint"), [applyTransformToPoint]("GI.Clutter.Objects.Actor#g:method:applyTransformToPoint"), [bindModel]("GI.Clutter.Objects.Actor#g:method:bindModel"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childGetProperty]("GI.Clutter.Interfaces.Container#g:method:childGetProperty"), [childNotify]("GI.Clutter.Interfaces.Container#g:method:childNotify"), [childSetProperty]("GI.Clutter.Interfaces.Container#g:method:childSetProperty"), [clearActions]("GI.Clutter.Objects.Actor#g:method:clearActions"), [clearConstraints]("GI.Clutter.Objects.Actor#g:method:clearConstraints"), [clearEffects]("GI.Clutter.Objects.Actor#g:method:clearEffects"), [contains]("GI.Clutter.Objects.Actor#g:method:contains"), [continuePaint]("GI.Clutter.Objects.Actor#g:method:continuePaint"), [createChildMeta]("GI.Clutter.Interfaces.Container#g:method:createChildMeta"), [createPangoContext]("GI.Clutter.Objects.Actor#g:method:createPangoContext"), [createPangoLayout]("GI.Clutter.Objects.Actor#g:method:createPangoLayout"), [destroy]("GI.Clutter.Objects.Actor#g:method:destroy"), [destroyAllChildren]("GI.Clutter.Objects.Actor#g:method:destroyAllChildren"), [destroyChildMeta]("GI.Clutter.Interfaces.Container#g:method:destroyChildMeta"), [detachAnimation]("GI.Clutter.Objects.Actor#g:method:detachAnimation"), [event]("GI.Clutter.Objects.Actor#g:method:event"), [findChildByName]("GI.Clutter.Interfaces.Container#g:method:findChildByName"), [findProperty]("GI.Clutter.Interfaces.Animatable#g:method:findProperty"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.Clutter.Interfaces.Container#g:method:foreach"), [foreachWithInternals]("GI.Clutter.Interfaces.Container#g:method:foreachWithInternals"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabKeyFocus]("GI.Clutter.Objects.Actor#g:method:grabKeyFocus"), [hasActions]("GI.Clutter.Objects.Actor#g:method:hasActions"), [hasAllocation]("GI.Clutter.Objects.Actor#g:method:hasAllocation"), [hasClip]("GI.Clutter.Objects.Actor#g:method:hasClip"), [hasConstraints]("GI.Clutter.Objects.Actor#g:method:hasConstraints"), [hasEffects]("GI.Clutter.Objects.Actor#g:method:hasEffects"), [hasKeyFocus]("GI.Clutter.Objects.Actor#g:method:hasKeyFocus"), [hasOverlaps]("GI.Clutter.Objects.Actor#g:method:hasOverlaps"), [hasPointer]("GI.Clutter.Objects.Actor#g:method:hasPointer"), [hide]("GI.Clutter.Objects.Actor#g:method:hide"), [hideAll]("GI.Clutter.Objects.Actor#g:method:hideAll"), [insertChildAbove]("GI.Clutter.Objects.Actor#g:method:insertChildAbove"), [insertChildAtIndex]("GI.Clutter.Objects.Actor#g:method:insertChildAtIndex"), [insertChildBelow]("GI.Clutter.Objects.Actor#g:method:insertChildBelow"), [interpolateValue]("GI.Clutter.Interfaces.Animatable#g:method:interpolateValue"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isInClonePaint]("GI.Clutter.Objects.Actor#g:method:isInClonePaint"), [isMapped]("GI.Clutter.Objects.Actor#g:method:isMapped"), [isRealized]("GI.Clutter.Objects.Actor#g:method:isRealized"), [isRotated]("GI.Clutter.Objects.Actor#g:method:isRotated"), [isScaled]("GI.Clutter.Objects.Actor#g:method:isScaled"), [isVisible]("GI.Clutter.Objects.Actor#g:method:isVisible"), [lower]("GI.Clutter.Objects.Actor#g:method:lower"), [lowerBottom]("GI.Clutter.Objects.Actor#g:method:lowerBottom"), [lowerChild]("GI.Clutter.Interfaces.Container#g:method:lowerChild"), [map]("GI.Clutter.Objects.Actor#g:method:map"), [moveAnchorPoint]("GI.Clutter.Objects.Actor#g:method:moveAnchorPoint"), [moveAnchorPointFromGravity]("GI.Clutter.Objects.Actor#g:method:moveAnchorPointFromGravity"), [moveBy]("GI.Clutter.Objects.Actor#g:method:moveBy"), [needsExpand]("GI.Clutter.Objects.Actor#g:method:needsExpand"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paint]("GI.Clutter.Objects.Actor#g:method:paint"), [parseCustomNode]("GI.Clutter.Interfaces.Scriptable#g:method:parseCustomNode"), [popInternal]("GI.Clutter.Objects.Actor#g:method:popInternal"), [pushInternal]("GI.Clutter.Objects.Actor#g:method:pushInternal"), [queueRedraw]("GI.Clutter.Objects.Actor#g:method:queueRedraw"), [queueRedrawWithClip]("GI.Clutter.Objects.Actor#g:method:queueRedrawWithClip"), [queueRelayout]("GI.Clutter.Objects.Actor#g:method:queueRelayout"), [raise]("GI.Clutter.Objects.Actor#g:method:raise"), [raiseChild]("GI.Clutter.Interfaces.Container#g:method:raiseChild"), [raiseTop]("GI.Clutter.Objects.Actor#g:method:raiseTop"), [realize]("GI.Clutter.Objects.Actor#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeAction]("GI.Clutter.Objects.Actor#g:method:removeAction"), [removeActionByName]("GI.Clutter.Objects.Actor#g:method:removeActionByName"), [removeActor]("GI.Clutter.Interfaces.Container#g:method:removeActor"), [removeAllChildren]("GI.Clutter.Objects.Actor#g:method:removeAllChildren"), [removeAllTransitions]("GI.Clutter.Objects.Actor#g:method:removeAllTransitions"), [removeChild]("GI.Clutter.Objects.Actor#g:method:removeChild"), [removeClip]("GI.Clutter.Objects.Actor#g:method:removeClip"), [removeConstraint]("GI.Clutter.Objects.Actor#g:method:removeConstraint"), [removeConstraintByName]("GI.Clutter.Objects.Actor#g:method:removeConstraintByName"), [removeEffect]("GI.Clutter.Objects.Actor#g:method:removeEffect"), [removeEffectByName]("GI.Clutter.Objects.Actor#g:method:removeEffectByName"), [removeTransition]("GI.Clutter.Objects.Actor#g:method:removeTransition"), [reparent]("GI.Clutter.Objects.Actor#g:method:reparent"), [replaceChild]("GI.Clutter.Objects.Actor#g:method:replaceChild"), [restoreEasingState]("GI.Clutter.Objects.Actor#g:method:restoreEasingState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [saveEasingState]("GI.Clutter.Objects.Actor#g:method:saveEasingState"), [shouldPickPaint]("GI.Clutter.Objects.Actor#g:method:shouldPickPaint"), [show]("GI.Clutter.Objects.Actor#g:method:show"), [showAll]("GI.Clutter.Objects.Actor#g:method:showAll"), [sortDepthOrder]("GI.Clutter.Interfaces.Container#g:method:sortDepthOrder"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [transformStagePoint]("GI.Clutter.Objects.Actor#g:method:transformStagePoint"), [unmap]("GI.Clutter.Objects.Actor#g:method:unmap"), [unparent]("GI.Clutter.Objects.Actor#g:method:unparent"), [unrealize]("GI.Clutter.Objects.Actor#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetFlags]("GI.Clutter.Objects.Actor#g:method:unsetFlags"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAbsAllocationVertices]("GI.Clutter.Objects.Actor#g:method:getAbsAllocationVertices"), [getAccessible]("GI.Clutter.Objects.Actor#g:method:getAccessible"), [getAction]("GI.Clutter.Objects.Actor#g:method:getAction"), [getActions]("GI.Clutter.Objects.Actor#g:method:getActions"), [getAllocationBox]("GI.Clutter.Objects.Actor#g:method:getAllocationBox"), [getAllocationGeometry]("GI.Clutter.Objects.Actor#g:method:getAllocationGeometry"), [getAllocationVertices]("GI.Clutter.Objects.Actor#g:method:getAllocationVertices"), [getAnchorPoint]("GI.Clutter.Objects.Actor#g:method:getAnchorPoint"), [getAnchorPointGravity]("GI.Clutter.Objects.Actor#g:method:getAnchorPointGravity"), [getAnimation]("GI.Clutter.Objects.Actor#g:method:getAnimation"), [getBackgroundColor]("GI.Clutter.Objects.Actor#g:method:getBackgroundColor"), [getBaseSize]("GI.Clutter.Objects.Texture#g:method:getBaseSize"), [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"), [getCoglMaterial]("GI.Clutter.Objects.Texture#g:method:getCoglMaterial"), [getCoglTexture]("GI.Clutter.Objects.Texture#g:method:getCoglTexture"), [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"), [getFilterQuality]("GI.Clutter.Objects.Texture#g:method:getFilterQuality"), [getFirstChild]("GI.Clutter.Objects.Actor#g:method:getFirstChild"), [getFixedPositionSet]("GI.Clutter.Objects.Actor#g:method:getFixedPositionSet"), [getFlags]("GI.Clutter.Objects.Actor#g:method:getFlags"), [getGeometry]("GI.Clutter.Objects.Actor#g:method:getGeometry"), [getGid]("GI.Clutter.Objects.Actor#g:method:getGid"), [getHeight]("GI.Clutter.Objects.Actor#g:method:getHeight"), [getId]("GI.Clutter.Interfaces.Scriptable#g:method:getId"), [getInitialState]("GI.Clutter.Interfaces.Animatable#g:method:getInitialState"), [getKeepAspectRatio]("GI.Clutter.Objects.Texture#g:method:getKeepAspectRatio"), [getLastChild]("GI.Clutter.Objects.Actor#g:method:getLastChild"), [getLayoutManager]("GI.Clutter.Objects.Actor#g:method:getLayoutManager"), [getLoadAsync]("GI.Clutter.Objects.Texture#g:method:getLoadAsync"), [getLoadDataAsync]("GI.Clutter.Objects.Texture#g:method:getLoadDataAsync"), [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"), [getMaxTileWaste]("GI.Clutter.Objects.Texture#g:method:getMaxTileWaste"), [getNChildren]("GI.Clutter.Objects.Actor#g:method:getNChildren"), [getName]("GI.Clutter.Objects.Actor#g:method:getName"), [getNextSibling]("GI.Clutter.Objects.Actor#g:method:getNextSibling"), [getOffscreenRedirect]("GI.Clutter.Objects.Actor#g:method:getOffscreenRedirect"), [getOpacity]("GI.Clutter.Objects.Actor#g:method:getOpacity"), [getPaintBox]("GI.Clutter.Objects.Actor#g:method:getPaintBox"), [getPaintOpacity]("GI.Clutter.Objects.Actor#g:method:getPaintOpacity"), [getPaintVisibility]("GI.Clutter.Objects.Actor#g:method:getPaintVisibility"), [getPaintVolume]("GI.Clutter.Objects.Actor#g:method:getPaintVolume"), [getPangoContext]("GI.Clutter.Objects.Actor#g:method:getPangoContext"), [getParent]("GI.Clutter.Objects.Actor#g:method:getParent"), [getPickWithAlpha]("GI.Clutter.Objects.Texture#g:method:getPickWithAlpha"), [getPivotPoint]("GI.Clutter.Objects.Actor#g:method:getPivotPoint"), [getPivotPointZ]("GI.Clutter.Objects.Actor#g:method:getPivotPointZ"), [getPixelFormat]("GI.Clutter.Objects.Texture#g:method:getPixelFormat"), [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"), [getRepeat]("GI.Clutter.Objects.Texture#g:method:getRepeat"), [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"), [getSyncSize]("GI.Clutter.Objects.Texture#g:method:getSyncSize"), [getTextDirection]("GI.Clutter.Objects.Actor#g:method:getTextDirection"), [getTransform]("GI.Clutter.Objects.Actor#g:method:getTransform"), [getTransformationMatrix]("GI.Clutter.Objects.Actor#g:method:getTransformationMatrix"), [getTransformedPaintVolume]("GI.Clutter.Objects.Actor#g:method:getTransformedPaintVolume"), [getTransformedPosition]("GI.Clutter.Objects.Actor#g:method:getTransformedPosition"), [getTransformedSize]("GI.Clutter.Objects.Actor#g:method:getTransformedSize"), [getTransition]("GI.Clutter.Objects.Actor#g:method:getTransition"), [getTranslation]("GI.Clutter.Objects.Actor#g:method:getTranslation"), [getWidth]("GI.Clutter.Objects.Actor#g:method:getWidth"), [getX]("GI.Clutter.Objects.Actor#g:method:getX"), [getXAlign]("GI.Clutter.Objects.Actor#g:method:getXAlign"), [getXExpand]("GI.Clutter.Objects.Actor#g:method:getXExpand"), [getY]("GI.Clutter.Objects.Actor#g:method:getY"), [getYAlign]("GI.Clutter.Objects.Actor#g:method:getYAlign"), [getYExpand]("GI.Clutter.Objects.Actor#g:method:getYExpand"), [getZPosition]("GI.Clutter.Objects.Actor#g:method:getZPosition"), [getZRotationGravity]("GI.Clutter.Objects.Actor#g:method:getZRotationGravity").
-- 
-- ==== Setters
-- [setAllocation]("GI.Clutter.Objects.Actor#g:method:setAllocation"), [setAnchorPoint]("GI.Clutter.Objects.Actor#g:method:setAnchorPoint"), [setAnchorPointFromGravity]("GI.Clutter.Objects.Actor#g:method:setAnchorPointFromGravity"), [setAreaFromRgbData]("GI.Clutter.Objects.Texture#g:method:setAreaFromRgbData"), [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"), [setCoglMaterial]("GI.Clutter.Objects.Texture#g:method:setCoglMaterial"), [setCoglTexture]("GI.Clutter.Objects.Texture#g:method:setCoglTexture"), [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"), [setFilterQuality]("GI.Clutter.Objects.Texture#g:method:setFilterQuality"), [setFinalState]("GI.Clutter.Interfaces.Animatable#g:method:setFinalState"), [setFixedPositionSet]("GI.Clutter.Objects.Actor#g:method:setFixedPositionSet"), [setFlags]("GI.Clutter.Objects.Actor#g:method:setFlags"), [setFromFile]("GI.Clutter.Objects.Texture#g:method:setFromFile"), [setFromRgbData]("GI.Clutter.Objects.Texture#g:method:setFromRgbData"), [setFromYuvData]("GI.Clutter.Objects.Texture#g:method:setFromYuvData"), [setGeometry]("GI.Clutter.Objects.Actor#g:method:setGeometry"), [setHeight]("GI.Clutter.Objects.Actor#g:method:setHeight"), [setId]("GI.Clutter.Interfaces.Scriptable#g:method:setId"), [setKeepAspectRatio]("GI.Clutter.Objects.Texture#g:method:setKeepAspectRatio"), [setLayoutManager]("GI.Clutter.Objects.Actor#g:method:setLayoutManager"), [setLoadAsync]("GI.Clutter.Objects.Texture#g:method:setLoadAsync"), [setLoadDataAsync]("GI.Clutter.Objects.Texture#g:method:setLoadDataAsync"), [setMargin]("GI.Clutter.Objects.Actor#g:method:setMargin"), [setMarginBottom]("GI.Clutter.Objects.Actor#g:method:setMarginBottom"), [setMarginLeft]("GI.Clutter.Objects.Actor#g:method:setMarginLeft"), [setMarginRight]("GI.Clutter.Objects.Actor#g:method:setMarginRight"), [setMarginTop]("GI.Clutter.Objects.Actor#g:method:setMarginTop"), [setName]("GI.Clutter.Objects.Actor#g:method:setName"), [setOffscreenRedirect]("GI.Clutter.Objects.Actor#g:method:setOffscreenRedirect"), [setOpacity]("GI.Clutter.Objects.Actor#g:method:setOpacity"), [setParent]("GI.Clutter.Objects.Actor#g:method:setParent"), [setPickWithAlpha]("GI.Clutter.Objects.Texture#g:method:setPickWithAlpha"), [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"), [setRepeat]("GI.Clutter.Objects.Texture#g:method:setRepeat"), [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"), [setSyncSize]("GI.Clutter.Objects.Texture#g:method:setSyncSize"), [setTextDirection]("GI.Clutter.Objects.Actor#g:method:setTextDirection"), [setTransform]("GI.Clutter.Objects.Actor#g:method:setTransform"), [setTranslation]("GI.Clutter.Objects.Actor#g:method:setTranslation"), [setWidth]("GI.Clutter.Objects.Actor#g:method:setWidth"), [setX]("GI.Clutter.Objects.Actor#g:method:setX"), [setXAlign]("GI.Clutter.Objects.Actor#g:method:setXAlign"), [setXExpand]("GI.Clutter.Objects.Actor#g:method:setXExpand"), [setY]("GI.Clutter.Objects.Actor#g:method:setY"), [setYAlign]("GI.Clutter.Objects.Actor#g:method:setYAlign"), [setYExpand]("GI.Clutter.Objects.Actor#g:method:setYExpand"), [setZPosition]("GI.Clutter.Objects.Actor#g:method:setZPosition"), [setZRotationFromGravity]("GI.Clutter.Objects.Actor#g:method:setZRotationFromGravity").

#if defined(ENABLE_OVERLOADING)
    ResolveTextureMethod                    ,
#endif

-- ** getBaseSize #method:getBaseSize#

#if defined(ENABLE_OVERLOADING)
    TextureGetBaseSizeMethodInfo            ,
#endif
    textureGetBaseSize                      ,


-- ** getCoglMaterial #method:getCoglMaterial#

#if defined(ENABLE_OVERLOADING)
    TextureGetCoglMaterialMethodInfo        ,
#endif
    textureGetCoglMaterial                  ,


-- ** getCoglTexture #method:getCoglTexture#

#if defined(ENABLE_OVERLOADING)
    TextureGetCoglTextureMethodInfo         ,
#endif
    textureGetCoglTexture                   ,


-- ** getFilterQuality #method:getFilterQuality#

#if defined(ENABLE_OVERLOADING)
    TextureGetFilterQualityMethodInfo       ,
#endif
    textureGetFilterQuality                 ,


-- ** getKeepAspectRatio #method:getKeepAspectRatio#

#if defined(ENABLE_OVERLOADING)
    TextureGetKeepAspectRatioMethodInfo     ,
#endif
    textureGetKeepAspectRatio               ,


-- ** getLoadAsync #method:getLoadAsync#

#if defined(ENABLE_OVERLOADING)
    TextureGetLoadAsyncMethodInfo           ,
#endif
    textureGetLoadAsync                     ,


-- ** getLoadDataAsync #method:getLoadDataAsync#

#if defined(ENABLE_OVERLOADING)
    TextureGetLoadDataAsyncMethodInfo       ,
#endif
    textureGetLoadDataAsync                 ,


-- ** getMaxTileWaste #method:getMaxTileWaste#

#if defined(ENABLE_OVERLOADING)
    TextureGetMaxTileWasteMethodInfo        ,
#endif
    textureGetMaxTileWaste                  ,


-- ** getPickWithAlpha #method:getPickWithAlpha#

#if defined(ENABLE_OVERLOADING)
    TextureGetPickWithAlphaMethodInfo       ,
#endif
    textureGetPickWithAlpha                 ,


-- ** getPixelFormat #method:getPixelFormat#

#if defined(ENABLE_OVERLOADING)
    TextureGetPixelFormatMethodInfo         ,
#endif
    textureGetPixelFormat                   ,


-- ** getRepeat #method:getRepeat#

#if defined(ENABLE_OVERLOADING)
    TextureGetRepeatMethodInfo              ,
#endif
    textureGetRepeat                        ,


-- ** getSyncSize #method:getSyncSize#

#if defined(ENABLE_OVERLOADING)
    TextureGetSyncSizeMethodInfo            ,
#endif
    textureGetSyncSize                      ,


-- ** new #method:new#

    textureNew                              ,


-- ** newFromActor #method:newFromActor#

    textureNewFromActor                     ,


-- ** newFromFile #method:newFromFile#

    textureNewFromFile                      ,


-- ** setAreaFromRgbData #method:setAreaFromRgbData#

#if defined(ENABLE_OVERLOADING)
    TextureSetAreaFromRgbDataMethodInfo     ,
#endif
    textureSetAreaFromRgbData               ,


-- ** setCoglMaterial #method:setCoglMaterial#

#if defined(ENABLE_OVERLOADING)
    TextureSetCoglMaterialMethodInfo        ,
#endif
    textureSetCoglMaterial                  ,


-- ** setCoglTexture #method:setCoglTexture#

#if defined(ENABLE_OVERLOADING)
    TextureSetCoglTextureMethodInfo         ,
#endif
    textureSetCoglTexture                   ,


-- ** setFilterQuality #method:setFilterQuality#

#if defined(ENABLE_OVERLOADING)
    TextureSetFilterQualityMethodInfo       ,
#endif
    textureSetFilterQuality                 ,


-- ** setFromFile #method:setFromFile#

#if defined(ENABLE_OVERLOADING)
    TextureSetFromFileMethodInfo            ,
#endif
    textureSetFromFile                      ,


-- ** setFromRgbData #method:setFromRgbData#

#if defined(ENABLE_OVERLOADING)
    TextureSetFromRgbDataMethodInfo         ,
#endif
    textureSetFromRgbData                   ,


-- ** setFromYuvData #method:setFromYuvData#

#if defined(ENABLE_OVERLOADING)
    TextureSetFromYuvDataMethodInfo         ,
#endif
    textureSetFromYuvData                   ,


-- ** setKeepAspectRatio #method:setKeepAspectRatio#

#if defined(ENABLE_OVERLOADING)
    TextureSetKeepAspectRatioMethodInfo     ,
#endif
    textureSetKeepAspectRatio               ,


-- ** setLoadAsync #method:setLoadAsync#

#if defined(ENABLE_OVERLOADING)
    TextureSetLoadAsyncMethodInfo           ,
#endif
    textureSetLoadAsync                     ,


-- ** setLoadDataAsync #method:setLoadDataAsync#

#if defined(ENABLE_OVERLOADING)
    TextureSetLoadDataAsyncMethodInfo       ,
#endif
    textureSetLoadDataAsync                 ,


-- ** setPickWithAlpha #method:setPickWithAlpha#

#if defined(ENABLE_OVERLOADING)
    TextureSetPickWithAlphaMethodInfo       ,
#endif
    textureSetPickWithAlpha                 ,


-- ** setRepeat #method:setRepeat#

#if defined(ENABLE_OVERLOADING)
    TextureSetRepeatMethodInfo              ,
#endif
    textureSetRepeat                        ,


-- ** setSyncSize #method:setSyncSize#

#if defined(ENABLE_OVERLOADING)
    TextureSetSyncSizeMethodInfo            ,
#endif
    textureSetSyncSize                      ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    TextureDisableSlicingPropertyInfo       ,
#endif
    constructTextureDisableSlicing          ,
    getTextureDisableSlicing                ,
#if defined(ENABLE_OVERLOADING)
    textureDisableSlicing                   ,
#endif


-- ** filename #attr:filename#
-- | The path of the file containing the image data to be displayed by
-- the texture.
-- 
-- This property is unset when using the clutter_texture_set_from_*@/_data()/@
-- family of functions.

#if defined(ENABLE_OVERLOADING)
    TextureFilenamePropertyInfo             ,
#endif
    clearTextureFilename                    ,
    constructTextureFilename                ,
    getTextureFilename                      ,
    setTextureFilename                      ,
#if defined(ENABLE_OVERLOADING)
    textureFilename                         ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextureFilterQualityPropertyInfo        ,
#endif
    constructTextureFilterQuality           ,
    getTextureFilterQuality                 ,
    setTextureFilterQuality                 ,
#if defined(ENABLE_OVERLOADING)
    textureFilterQuality                    ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextureKeepAspectRatioPropertyInfo      ,
#endif
    constructTextureKeepAspectRatio         ,
    getTextureKeepAspectRatio               ,
    setTextureKeepAspectRatio               ,
#if defined(ENABLE_OVERLOADING)
    textureKeepAspectRatio                  ,
#endif


-- ** loadAsync #attr:loadAsync#
-- | Tries to load a texture from a filename by using a local thread to perform
-- the read operations. The initially created texture has dimensions 0x0 when
-- the true size becomes available the [Texture::sizeChange]("GI.Clutter.Objects.Texture#g:signal:sizeChange") signal is
-- emitted and when the image has completed loading the
-- [Texture::loadFinished]("GI.Clutter.Objects.Texture#g:signal:loadFinished") signal is emitted.
-- 
-- Threading is only enabled if @/g_thread_init()/@ has been called prior to
-- 'GI.Clutter.Functions.init', otherwise t'GI.Clutter.Objects.Texture.Texture' will use the main loop to load
-- the image.
-- 
-- The upload of the texture data on the GL pipeline is not asynchronous, as
-- it must be performed from within the same thread that called
-- 'GI.Clutter.Functions.main'.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextureLoadAsyncPropertyInfo            ,
#endif
    constructTextureLoadAsync               ,
    setTextureLoadAsync                     ,
#if defined(ENABLE_OVERLOADING)
    textureLoadAsync                        ,
#endif


-- ** loadDataAsync #attr:loadDataAsync#
-- | Like [Texture:loadAsync]("GI.Clutter.Objects.Texture#g:attr:loadAsync") but loads the width and height
-- synchronously causing some blocking.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextureLoadDataAsyncPropertyInfo        ,
#endif
    constructTextureLoadDataAsync           ,
    setTextureLoadDataAsync                 ,
#if defined(ENABLE_OVERLOADING)
    textureLoadDataAsync                    ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TexturePickWithAlphaPropertyInfo        ,
#endif
    constructTexturePickWithAlpha           ,
    getTexturePickWithAlpha                 ,
    setTexturePickWithAlpha                 ,
#if defined(ENABLE_OVERLOADING)
    texturePickWithAlpha                    ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TexturePixelFormatPropertyInfo          ,
#endif
    getTexturePixelFormat                   ,
#if defined(ENABLE_OVERLOADING)
    texturePixelFormat                      ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextureRepeatXPropertyInfo              ,
#endif
    constructTextureRepeatX                 ,
    getTextureRepeatX                       ,
    setTextureRepeatX                       ,
#if defined(ENABLE_OVERLOADING)
    textureRepeatX                          ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextureRepeatYPropertyInfo              ,
#endif
    constructTextureRepeatY                 ,
    getTextureRepeatY                       ,
    setTextureRepeatY                       ,
#if defined(ENABLE_OVERLOADING)
    textureRepeatY                          ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextureSyncSizePropertyInfo             ,
#endif
    constructTextureSyncSize                ,
    getTextureSyncSize                      ,
    setTextureSyncSize                      ,
#if defined(ENABLE_OVERLOADING)
    textureSyncSize                         ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextureTileWastePropertyInfo            ,
#endif
    getTextureTileWaste                     ,
#if defined(ENABLE_OVERLOADING)
    textureTileWaste                        ,
#endif




 -- * Signals


-- ** loadFinished #signal:loadFinished#

    TextureLoadFinishedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TextureLoadFinishedSignalInfo           ,
#endif
    afterTextureLoadFinished                ,
    onTextureLoadFinished                   ,


-- ** pixbufChange #signal:pixbufChange#

    TexturePixbufChangeCallback             ,
#if defined(ENABLE_OVERLOADING)
    TexturePixbufChangeSignalInfo           ,
#endif
    afterTexturePixbufChange                ,
    onTexturePixbufChange                   ,


-- ** sizeChange #signal:sizeChange#

    TextureSizeChangeCallback               ,
#if defined(ENABLE_OVERLOADING)
    TextureSizeChangeSignalInfo             ,
#endif
    afterTextureSizeChange                  ,
    onTextureSizeChange                     ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Animatable as Clutter.Animatable
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Container as Clutter.Container
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import qualified GI.Cogl.Enums as Cogl.Enums
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "clutter_texture_get_type"
    c_clutter_texture_get_type :: IO B.Types.GType

instance B.Types.TypedObject Texture where
    glibType :: IO GType
glibType = IO GType
c_clutter_texture_get_type

instance B.Types.GObject Texture

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

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

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

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

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

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

#endif

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

#endif

-- signal Texture::load-finished
{-# DEPRECATED TextureLoadFinishedCallback ["(Since version 1.12)","No replacement is available"] #-}
-- | The [loadFinished](#g:signal:loadFinished) signal is emitted when a texture load has
-- completed. If there was an error during loading, /@error@/ will
-- be set, otherwise it will be 'P.Nothing'
-- 
-- /Since: 1.0/
type TextureLoadFinishedCallback =
    GError
    -- ^ /@error@/: A set error, or 'P.Nothing'
    -> IO ()

type C_TextureLoadFinishedCallback =
    Ptr Texture ->                          -- object
    Ptr GError ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TextureLoadFinishedCallback :: 
    GObject a => (a -> TextureLoadFinishedCallback) ->
    C_TextureLoadFinishedCallback
wrap_TextureLoadFinishedCallback :: forall a.
GObject a =>
(a -> TextureLoadFinishedCallback) -> C_TextureLoadFinishedCallback
wrap_TextureLoadFinishedCallback a -> TextureLoadFinishedCallback
gi'cb Ptr Texture
gi'selfPtr Ptr GError
error_ Ptr ()
_ = do
    GError
error_' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GError -> GError
GError) Ptr GError
error_
    Ptr Texture -> (Texture -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Texture
gi'selfPtr ((Texture -> IO ()) -> IO ()) -> (Texture -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Texture
gi'self -> a -> TextureLoadFinishedCallback
gi'cb (Texture -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Texture
gi'self)  GError
error_'


-- | Connect a signal handler for the [loadFinished](#signal:loadFinished) 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' texture #loadFinished callback
-- @
-- 
-- 
onTextureLoadFinished :: (IsTexture a, MonadIO m) => a -> ((?self :: a) => TextureLoadFinishedCallback) -> m SignalHandlerId
onTextureLoadFinished :: forall a (m :: * -> *).
(IsTexture a, MonadIO m) =>
a
-> ((?self::a) => TextureLoadFinishedCallback) -> m SignalHandlerId
onTextureLoadFinished a
obj (?self::a) => TextureLoadFinishedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextureLoadFinishedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextureLoadFinishedCallback
TextureLoadFinishedCallback
cb
    let wrapped' :: C_TextureLoadFinishedCallback
wrapped' = (a -> TextureLoadFinishedCallback) -> C_TextureLoadFinishedCallback
forall a.
GObject a =>
(a -> TextureLoadFinishedCallback) -> C_TextureLoadFinishedCallback
wrap_TextureLoadFinishedCallback a -> TextureLoadFinishedCallback
wrapped
    FunPtr C_TextureLoadFinishedCallback
wrapped'' <- C_TextureLoadFinishedCallback
-> IO (FunPtr C_TextureLoadFinishedCallback)
mk_TextureLoadFinishedCallback C_TextureLoadFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_TextureLoadFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"load-finished" FunPtr C_TextureLoadFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [loadFinished](#signal:loadFinished) 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' texture #loadFinished 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.
-- 
afterTextureLoadFinished :: (IsTexture a, MonadIO m) => a -> ((?self :: a) => TextureLoadFinishedCallback) -> m SignalHandlerId
afterTextureLoadFinished :: forall a (m :: * -> *).
(IsTexture a, MonadIO m) =>
a
-> ((?self::a) => TextureLoadFinishedCallback) -> m SignalHandlerId
afterTextureLoadFinished a
obj (?self::a) => TextureLoadFinishedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextureLoadFinishedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextureLoadFinishedCallback
TextureLoadFinishedCallback
cb
    let wrapped' :: C_TextureLoadFinishedCallback
wrapped' = (a -> TextureLoadFinishedCallback) -> C_TextureLoadFinishedCallback
forall a.
GObject a =>
(a -> TextureLoadFinishedCallback) -> C_TextureLoadFinishedCallback
wrap_TextureLoadFinishedCallback a -> TextureLoadFinishedCallback
wrapped
    FunPtr C_TextureLoadFinishedCallback
wrapped'' <- C_TextureLoadFinishedCallback
-> IO (FunPtr C_TextureLoadFinishedCallback)
mk_TextureLoadFinishedCallback C_TextureLoadFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_TextureLoadFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"load-finished" FunPtr C_TextureLoadFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextureLoadFinishedSignalInfo
instance SignalInfo TextureLoadFinishedSignalInfo where
    type HaskellCallbackType TextureLoadFinishedSignalInfo = TextureLoadFinishedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextureLoadFinishedCallback cb
        cb'' <- mk_TextureLoadFinishedCallback cb'
        connectSignalFunPtr obj "load-finished" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture::load-finished"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:signal:loadFinished"})

#endif

-- signal Texture::pixbuf-change
{-# DEPRECATED TexturePixbufChangeCallback ["(Since version 1.12)","No replacement is available"] #-}
-- | The [pixbufChange](#g:signal:pixbufChange) signal is emitted each time the pixbuf
-- used by /@texture@/ changes.
type TexturePixbufChangeCallback =
    IO ()

type C_TexturePixbufChangeCallback =
    Ptr Texture ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TexturePixbufChangeCallback :: 
    GObject a => (a -> TexturePixbufChangeCallback) ->
    C_TexturePixbufChangeCallback
wrap_TexturePixbufChangeCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_TexturePixbufChangeCallback
wrap_TexturePixbufChangeCallback a -> IO ()
gi'cb Ptr Texture
gi'selfPtr Ptr ()
_ = do
    Ptr Texture -> (Texture -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Texture
gi'selfPtr ((Texture -> IO ()) -> IO ()) -> (Texture -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Texture
gi'self -> a -> IO ()
gi'cb (Texture -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Texture
gi'self) 


-- | Connect a signal handler for the [pixbufChange](#signal:pixbufChange) 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' texture #pixbufChange callback
-- @
-- 
-- 
onTexturePixbufChange :: (IsTexture a, MonadIO m) => a -> ((?self :: a) => TexturePixbufChangeCallback) -> m SignalHandlerId
onTexturePixbufChange :: forall a (m :: * -> *).
(IsTexture a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTexturePixbufChange a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TexturePixbufChangeCallback
wrapped' = (a -> IO ()) -> C_TexturePixbufChangeCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TexturePixbufChangeCallback
wrap_TexturePixbufChangeCallback a -> IO ()
wrapped
    FunPtr C_TexturePixbufChangeCallback
wrapped'' <- C_TexturePixbufChangeCallback
-> IO (FunPtr C_TexturePixbufChangeCallback)
mk_TexturePixbufChangeCallback C_TexturePixbufChangeCallback
wrapped'
    a
-> Text
-> FunPtr C_TexturePixbufChangeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pixbuf-change" FunPtr C_TexturePixbufChangeCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pixbufChange](#signal:pixbufChange) 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' texture #pixbufChange 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.
-- 
afterTexturePixbufChange :: (IsTexture a, MonadIO m) => a -> ((?self :: a) => TexturePixbufChangeCallback) -> m SignalHandlerId
afterTexturePixbufChange :: forall a (m :: * -> *).
(IsTexture a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTexturePixbufChange a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TexturePixbufChangeCallback
wrapped' = (a -> IO ()) -> C_TexturePixbufChangeCallback
forall a.
GObject a =>
(a -> IO ()) -> C_TexturePixbufChangeCallback
wrap_TexturePixbufChangeCallback a -> IO ()
wrapped
    FunPtr C_TexturePixbufChangeCallback
wrapped'' <- C_TexturePixbufChangeCallback
-> IO (FunPtr C_TexturePixbufChangeCallback)
mk_TexturePixbufChangeCallback C_TexturePixbufChangeCallback
wrapped'
    a
-> Text
-> FunPtr C_TexturePixbufChangeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pixbuf-change" FunPtr C_TexturePixbufChangeCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TexturePixbufChangeSignalInfo
instance SignalInfo TexturePixbufChangeSignalInfo where
    type HaskellCallbackType TexturePixbufChangeSignalInfo = TexturePixbufChangeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TexturePixbufChangeCallback cb
        cb'' <- mk_TexturePixbufChangeCallback cb'
        connectSignalFunPtr obj "pixbuf-change" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture::pixbuf-change"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:signal:pixbufChange"})

#endif

-- signal Texture::size-change
{-# DEPRECATED TextureSizeChangeCallback ["(Since version 1.12)","No replacement is available"] #-}
-- | The [sizeChange](#g:signal:sizeChange) signal is emitted each time the size of the
-- pixbuf used by /@texture@/ changes.  The new size is given as
-- argument to the callback.
type TextureSizeChangeCallback =
    Int32
    -- ^ /@width@/: the width of the new texture
    -> Int32
    -- ^ /@height@/: the height of the new texture
    -> IO ()

type C_TextureSizeChangeCallback =
    Ptr Texture ->                          -- object
    Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TextureSizeChangeCallback :: 
    GObject a => (a -> TextureSizeChangeCallback) ->
    C_TextureSizeChangeCallback
wrap_TextureSizeChangeCallback :: forall a.
GObject a =>
(a -> TextureSizeChangeCallback) -> C_TextureSizeChangeCallback
wrap_TextureSizeChangeCallback a -> TextureSizeChangeCallback
gi'cb Ptr Texture
gi'selfPtr Int32
width Int32
height Ptr ()
_ = do
    Ptr Texture -> (Texture -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Texture
gi'selfPtr ((Texture -> IO ()) -> IO ()) -> (Texture -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Texture
gi'self -> a -> TextureSizeChangeCallback
gi'cb (Texture -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Texture
gi'self)  Int32
width Int32
height


-- | Connect a signal handler for the [sizeChange](#signal:sizeChange) 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' texture #sizeChange callback
-- @
-- 
-- 
onTextureSizeChange :: (IsTexture a, MonadIO m) => a -> ((?self :: a) => TextureSizeChangeCallback) -> m SignalHandlerId
onTextureSizeChange :: forall a (m :: * -> *).
(IsTexture a, MonadIO m) =>
a -> ((?self::a) => TextureSizeChangeCallback) -> m SignalHandlerId
onTextureSizeChange a
obj (?self::a) => TextureSizeChangeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextureSizeChangeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextureSizeChangeCallback
TextureSizeChangeCallback
cb
    let wrapped' :: C_TextureSizeChangeCallback
wrapped' = (a -> TextureSizeChangeCallback) -> C_TextureSizeChangeCallback
forall a.
GObject a =>
(a -> TextureSizeChangeCallback) -> C_TextureSizeChangeCallback
wrap_TextureSizeChangeCallback a -> TextureSizeChangeCallback
wrapped
    FunPtr C_TextureSizeChangeCallback
wrapped'' <- C_TextureSizeChangeCallback
-> IO (FunPtr C_TextureSizeChangeCallback)
mk_TextureSizeChangeCallback C_TextureSizeChangeCallback
wrapped'
    a
-> Text
-> FunPtr C_TextureSizeChangeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"size-change" FunPtr C_TextureSizeChangeCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [sizeChange](#signal:sizeChange) 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' texture #sizeChange 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.
-- 
afterTextureSizeChange :: (IsTexture a, MonadIO m) => a -> ((?self :: a) => TextureSizeChangeCallback) -> m SignalHandlerId
afterTextureSizeChange :: forall a (m :: * -> *).
(IsTexture a, MonadIO m) =>
a -> ((?self::a) => TextureSizeChangeCallback) -> m SignalHandlerId
afterTextureSizeChange a
obj (?self::a) => TextureSizeChangeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextureSizeChangeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextureSizeChangeCallback
TextureSizeChangeCallback
cb
    let wrapped' :: C_TextureSizeChangeCallback
wrapped' = (a -> TextureSizeChangeCallback) -> C_TextureSizeChangeCallback
forall a.
GObject a =>
(a -> TextureSizeChangeCallback) -> C_TextureSizeChangeCallback
wrap_TextureSizeChangeCallback a -> TextureSizeChangeCallback
wrapped
    FunPtr C_TextureSizeChangeCallback
wrapped'' <- C_TextureSizeChangeCallback
-> IO (FunPtr C_TextureSizeChangeCallback)
mk_TextureSizeChangeCallback C_TextureSizeChangeCallback
wrapped'
    a
-> Text
-> FunPtr C_TextureSizeChangeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"size-change" FunPtr C_TextureSizeChangeCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextureSizeChangeSignalInfo
instance SignalInfo TextureSizeChangeSignalInfo where
    type HaskellCallbackType TextureSizeChangeSignalInfo = TextureSizeChangeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextureSizeChangeCallback cb
        cb'' <- mk_TextureSizeChangeCallback cb'
        connectSignalFunPtr obj "size-change" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture::size-change"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:signal:sizeChange"})

#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextureDisableSlicingPropertyInfo
instance AttrInfo TextureDisableSlicingPropertyInfo where
    type AttrAllowedOps TextureDisableSlicingPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextureDisableSlicingPropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureDisableSlicingPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TextureDisableSlicingPropertyInfo = (~) Bool
    type AttrTransferType TextureDisableSlicingPropertyInfo = Bool
    type AttrGetType TextureDisableSlicingPropertyInfo = Bool
    type AttrLabel TextureDisableSlicingPropertyInfo = "disable-slicing"
    type AttrOrigin TextureDisableSlicingPropertyInfo = Texture
    attrGet = getTextureDisableSlicing
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureDisableSlicing
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.disableSlicing"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:disableSlicing"
        })
#endif

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

-- | Get the value of the “@filename@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' texture #filename
-- @
getTextureFilename :: (MonadIO m, IsTexture o) => o -> m (Maybe T.Text)
getTextureFilename :: forall (m :: * -> *) o.
(MonadIO m, IsTexture o) =>
o -> m (Maybe Text)
getTextureFilename o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe 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
"filename"

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

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

-- | Set the value of the “@filename@” 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' #filename
-- @
clearTextureFilename :: (MonadIO m, IsTexture o) => o -> m ()
clearTextureFilename :: forall (m :: * -> *) o. (MonadIO m, IsTexture o) => o -> m ()
clearTextureFilename o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"filename" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data TextureFilenamePropertyInfo
instance AttrInfo TextureFilenamePropertyInfo where
    type AttrAllowedOps TextureFilenamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TextureFilenamePropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureFilenamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TextureFilenamePropertyInfo = (~) T.Text
    type AttrTransferType TextureFilenamePropertyInfo = T.Text
    type AttrGetType TextureFilenamePropertyInfo = (Maybe T.Text)
    type AttrLabel TextureFilenamePropertyInfo = "filename"
    type AttrOrigin TextureFilenamePropertyInfo = Texture
    attrGet = getTextureFilename
    attrSet = setTextureFilename
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureFilename
    attrClear = clearTextureFilename
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.filename"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:filename"
        })
#endif

-- VVV Prop "filter-quality"
   -- Type: TInterface (Name {namespace = "Clutter", name = "TextureQuality"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextureFilterQualityPropertyInfo
instance AttrInfo TextureFilterQualityPropertyInfo where
    type AttrAllowedOps TextureFilterQualityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextureFilterQualityPropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureFilterQualityPropertyInfo = (~) Clutter.Enums.TextureQuality
    type AttrTransferTypeConstraint TextureFilterQualityPropertyInfo = (~) Clutter.Enums.TextureQuality
    type AttrTransferType TextureFilterQualityPropertyInfo = Clutter.Enums.TextureQuality
    type AttrGetType TextureFilterQualityPropertyInfo = Clutter.Enums.TextureQuality
    type AttrLabel TextureFilterQualityPropertyInfo = "filter-quality"
    type AttrOrigin TextureFilterQualityPropertyInfo = Texture
    attrGet = getTextureFilterQuality
    attrSet = setTextureFilterQuality
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureFilterQuality
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.filterQuality"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:filterQuality"
        })
#endif

-- VVV Prop "keep-aspect-ratio"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextureKeepAspectRatioPropertyInfo
instance AttrInfo TextureKeepAspectRatioPropertyInfo where
    type AttrAllowedOps TextureKeepAspectRatioPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextureKeepAspectRatioPropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureKeepAspectRatioPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TextureKeepAspectRatioPropertyInfo = (~) Bool
    type AttrTransferType TextureKeepAspectRatioPropertyInfo = Bool
    type AttrGetType TextureKeepAspectRatioPropertyInfo = Bool
    type AttrLabel TextureKeepAspectRatioPropertyInfo = "keep-aspect-ratio"
    type AttrOrigin TextureKeepAspectRatioPropertyInfo = Texture
    attrGet = getTextureKeepAspectRatio
    attrSet = setTextureKeepAspectRatio
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureKeepAspectRatio
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.keepAspectRatio"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:keepAspectRatio"
        })
#endif

-- VVV Prop "load-async"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

#if defined(ENABLE_OVERLOADING)
data TextureLoadAsyncPropertyInfo
instance AttrInfo TextureLoadAsyncPropertyInfo where
    type AttrAllowedOps TextureLoadAsyncPropertyInfo = '[ 'AttrSet, 'AttrConstruct]
    type AttrBaseTypeConstraint TextureLoadAsyncPropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureLoadAsyncPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TextureLoadAsyncPropertyInfo = (~) Bool
    type AttrTransferType TextureLoadAsyncPropertyInfo = Bool
    type AttrGetType TextureLoadAsyncPropertyInfo = ()
    type AttrLabel TextureLoadAsyncPropertyInfo = "load-async"
    type AttrOrigin TextureLoadAsyncPropertyInfo = Texture
    attrGet = undefined
    attrSet = setTextureLoadAsync
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureLoadAsync
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.loadAsync"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:loadAsync"
        })
#endif

-- VVV Prop "load-data-async"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

#if defined(ENABLE_OVERLOADING)
data TextureLoadDataAsyncPropertyInfo
instance AttrInfo TextureLoadDataAsyncPropertyInfo where
    type AttrAllowedOps TextureLoadDataAsyncPropertyInfo = '[ 'AttrSet, 'AttrConstruct]
    type AttrBaseTypeConstraint TextureLoadDataAsyncPropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureLoadDataAsyncPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TextureLoadDataAsyncPropertyInfo = (~) Bool
    type AttrTransferType TextureLoadDataAsyncPropertyInfo = Bool
    type AttrGetType TextureLoadDataAsyncPropertyInfo = ()
    type AttrLabel TextureLoadDataAsyncPropertyInfo = "load-data-async"
    type AttrOrigin TextureLoadDataAsyncPropertyInfo = Texture
    attrGet = undefined
    attrSet = setTextureLoadDataAsync
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureLoadDataAsync
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.loadDataAsync"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:loadDataAsync"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TexturePickWithAlphaPropertyInfo
instance AttrInfo TexturePickWithAlphaPropertyInfo where
    type AttrAllowedOps TexturePickWithAlphaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TexturePickWithAlphaPropertyInfo = IsTexture
    type AttrSetTypeConstraint TexturePickWithAlphaPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TexturePickWithAlphaPropertyInfo = (~) Bool
    type AttrTransferType TexturePickWithAlphaPropertyInfo = Bool
    type AttrGetType TexturePickWithAlphaPropertyInfo = Bool
    type AttrLabel TexturePickWithAlphaPropertyInfo = "pick-with-alpha"
    type AttrOrigin TexturePickWithAlphaPropertyInfo = Texture
    attrGet = getTexturePickWithAlpha
    attrSet = setTexturePickWithAlpha
    attrTransfer _ v = do
        return v
    attrConstruct = constructTexturePickWithAlpha
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.pickWithAlpha"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:pickWithAlpha"
        })
#endif

-- VVV Prop "pixel-format"
   -- Type: TInterface (Name {namespace = "Cogl", name = "PixelFormat"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@pixel-format@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' texture #pixelFormat
-- @
getTexturePixelFormat :: (MonadIO m, IsTexture o) => o -> m Cogl.Enums.PixelFormat
getTexturePixelFormat :: forall (m :: * -> *) o.
(MonadIO m, IsTexture o) =>
o -> m PixelFormat
getTexturePixelFormat o
obj = IO PixelFormat -> m PixelFormat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO PixelFormat -> m PixelFormat)
-> IO PixelFormat -> m PixelFormat
forall a b. (a -> b) -> a -> b
$ o -> String -> IO PixelFormat
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"pixel-format"

#if defined(ENABLE_OVERLOADING)
data TexturePixelFormatPropertyInfo
instance AttrInfo TexturePixelFormatPropertyInfo where
    type AttrAllowedOps TexturePixelFormatPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TexturePixelFormatPropertyInfo = IsTexture
    type AttrSetTypeConstraint TexturePixelFormatPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TexturePixelFormatPropertyInfo = (~) ()
    type AttrTransferType TexturePixelFormatPropertyInfo = ()
    type AttrGetType TexturePixelFormatPropertyInfo = Cogl.Enums.PixelFormat
    type AttrLabel TexturePixelFormatPropertyInfo = "pixel-format"
    type AttrOrigin TexturePixelFormatPropertyInfo = Texture
    attrGet = getTexturePixelFormat
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.pixelFormat"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:pixelFormat"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextureRepeatXPropertyInfo
instance AttrInfo TextureRepeatXPropertyInfo where
    type AttrAllowedOps TextureRepeatXPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextureRepeatXPropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureRepeatXPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TextureRepeatXPropertyInfo = (~) Bool
    type AttrTransferType TextureRepeatXPropertyInfo = Bool
    type AttrGetType TextureRepeatXPropertyInfo = Bool
    type AttrLabel TextureRepeatXPropertyInfo = "repeat-x"
    type AttrOrigin TextureRepeatXPropertyInfo = Texture
    attrGet = getTextureRepeatX
    attrSet = setTextureRepeatX
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureRepeatX
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.repeatX"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:repeatX"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextureRepeatYPropertyInfo
instance AttrInfo TextureRepeatYPropertyInfo where
    type AttrAllowedOps TextureRepeatYPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextureRepeatYPropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureRepeatYPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TextureRepeatYPropertyInfo = (~) Bool
    type AttrTransferType TextureRepeatYPropertyInfo = Bool
    type AttrGetType TextureRepeatYPropertyInfo = Bool
    type AttrLabel TextureRepeatYPropertyInfo = "repeat-y"
    type AttrOrigin TextureRepeatYPropertyInfo = Texture
    attrGet = getTextureRepeatY
    attrSet = setTextureRepeatY
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureRepeatY
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.repeatY"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:repeatY"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextureSyncSizePropertyInfo
instance AttrInfo TextureSyncSizePropertyInfo where
    type AttrAllowedOps TextureSyncSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextureSyncSizePropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureSyncSizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TextureSyncSizePropertyInfo = (~) Bool
    type AttrTransferType TextureSyncSizePropertyInfo = Bool
    type AttrGetType TextureSyncSizePropertyInfo = Bool
    type AttrLabel TextureSyncSizePropertyInfo = "sync-size"
    type AttrOrigin TextureSyncSizePropertyInfo = Texture
    attrGet = getTextureSyncSize
    attrSet = setTextureSyncSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextureSyncSize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.syncSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:syncSize"
        })
#endif

-- VVV Prop "tile-waste"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data TextureTileWastePropertyInfo
instance AttrInfo TextureTileWastePropertyInfo where
    type AttrAllowedOps TextureTileWastePropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TextureTileWastePropertyInfo = IsTexture
    type AttrSetTypeConstraint TextureTileWastePropertyInfo = (~) ()
    type AttrTransferTypeConstraint TextureTileWastePropertyInfo = (~) ()
    type AttrTransferType TextureTileWastePropertyInfo = ()
    type AttrGetType TextureTileWastePropertyInfo = Int32
    type AttrLabel TextureTileWastePropertyInfo = "tile-waste"
    type AttrOrigin TextureTileWastePropertyInfo = Texture
    attrGet = getTextureTileWaste
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Texture.tileWaste"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-Texture.html#g:attr:tileWaste"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Texture
type instance O.AttributeList Texture = TextureAttributeList
type TextureAttributeList = ('[ '("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), '("constraints", Clutter.Actor.ActorConstraintsPropertyInfo), '("content", Clutter.Actor.ActorContentPropertyInfo), '("contentBox", Clutter.Actor.ActorContentBoxPropertyInfo), '("contentGravity", Clutter.Actor.ActorContentGravityPropertyInfo), '("contentRepeat", Clutter.Actor.ActorContentRepeatPropertyInfo), '("depth", Clutter.Actor.ActorDepthPropertyInfo), '("disableSlicing", TextureDisableSlicingPropertyInfo), '("effect", Clutter.Actor.ActorEffectPropertyInfo), '("filename", TextureFilenamePropertyInfo), '("filterQuality", TextureFilterQualityPropertyInfo), '("firstChild", Clutter.Actor.ActorFirstChildPropertyInfo), '("fixedPositionSet", Clutter.Actor.ActorFixedPositionSetPropertyInfo), '("fixedX", Clutter.Actor.ActorFixedXPropertyInfo), '("fixedY", Clutter.Actor.ActorFixedYPropertyInfo), '("hasClip", Clutter.Actor.ActorHasClipPropertyInfo), '("hasPointer", Clutter.Actor.ActorHasPointerPropertyInfo), '("height", Clutter.Actor.ActorHeightPropertyInfo), '("keepAspectRatio", TextureKeepAspectRatioPropertyInfo), '("lastChild", Clutter.Actor.ActorLastChildPropertyInfo), '("layoutManager", Clutter.Actor.ActorLayoutManagerPropertyInfo), '("loadAsync", TextureLoadAsyncPropertyInfo), '("loadDataAsync", TextureLoadDataAsyncPropertyInfo), '("magnificationFilter", Clutter.Actor.ActorMagnificationFilterPropertyInfo), '("mapped", Clutter.Actor.ActorMappedPropertyInfo), '("marginBottom", Clutter.Actor.ActorMarginBottomPropertyInfo), '("marginLeft", Clutter.Actor.ActorMarginLeftPropertyInfo), '("marginRight", Clutter.Actor.ActorMarginRightPropertyInfo), '("marginTop", Clutter.Actor.ActorMarginTopPropertyInfo), '("minHeight", Clutter.Actor.ActorMinHeightPropertyInfo), '("minHeightSet", Clutter.Actor.ActorMinHeightSetPropertyInfo), '("minWidth", Clutter.Actor.ActorMinWidthPropertyInfo), '("minWidthSet", Clutter.Actor.ActorMinWidthSetPropertyInfo), '("minificationFilter", Clutter.Actor.ActorMinificationFilterPropertyInfo), '("name", Clutter.Actor.ActorNamePropertyInfo), '("naturalHeight", Clutter.Actor.ActorNaturalHeightPropertyInfo), '("naturalHeightSet", Clutter.Actor.ActorNaturalHeightSetPropertyInfo), '("naturalWidth", Clutter.Actor.ActorNaturalWidthPropertyInfo), '("naturalWidthSet", Clutter.Actor.ActorNaturalWidthSetPropertyInfo), '("offscreenRedirect", Clutter.Actor.ActorOffscreenRedirectPropertyInfo), '("opacity", Clutter.Actor.ActorOpacityPropertyInfo), '("pickWithAlpha", TexturePickWithAlphaPropertyInfo), '("pivotPoint", Clutter.Actor.ActorPivotPointPropertyInfo), '("pivotPointZ", Clutter.Actor.ActorPivotPointZPropertyInfo), '("pixelFormat", TexturePixelFormatPropertyInfo), '("position", Clutter.Actor.ActorPositionPropertyInfo), '("reactive", Clutter.Actor.ActorReactivePropertyInfo), '("realized", Clutter.Actor.ActorRealizedPropertyInfo), '("repeatX", TextureRepeatXPropertyInfo), '("repeatY", TextureRepeatYPropertyInfo), '("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), '("syncSize", TextureSyncSizePropertyInfo), '("textDirection", Clutter.Actor.ActorTextDirectionPropertyInfo), '("tileWaste", TextureTileWastePropertyInfo), '("transform", Clutter.Actor.ActorTransformPropertyInfo), '("transformSet", Clutter.Actor.ActorTransformSetPropertyInfo), '("translationX", Clutter.Actor.ActorTranslationXPropertyInfo), '("translationY", Clutter.Actor.ActorTranslationYPropertyInfo), '("translationZ", Clutter.Actor.ActorTranslationZPropertyInfo), '("visible", Clutter.Actor.ActorVisiblePropertyInfo), '("width", Clutter.Actor.ActorWidthPropertyInfo), '("x", Clutter.Actor.ActorXPropertyInfo), '("xAlign", Clutter.Actor.ActorXAlignPropertyInfo), '("xExpand", Clutter.Actor.ActorXExpandPropertyInfo), '("y", Clutter.Actor.ActorYPropertyInfo), '("yAlign", Clutter.Actor.ActorYAlignPropertyInfo), '("yExpand", Clutter.Actor.ActorYExpandPropertyInfo), '("zPosition", Clutter.Actor.ActorZPositionPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
textureDisableSlicing :: AttrLabelProxy "disableSlicing"
textureDisableSlicing = AttrLabelProxy

textureFilename :: AttrLabelProxy "filename"
textureFilename = AttrLabelProxy

textureFilterQuality :: AttrLabelProxy "filterQuality"
textureFilterQuality = AttrLabelProxy

textureKeepAspectRatio :: AttrLabelProxy "keepAspectRatio"
textureKeepAspectRatio = AttrLabelProxy

textureLoadAsync :: AttrLabelProxy "loadAsync"
textureLoadAsync = AttrLabelProxy

textureLoadDataAsync :: AttrLabelProxy "loadDataAsync"
textureLoadDataAsync = AttrLabelProxy

texturePickWithAlpha :: AttrLabelProxy "pickWithAlpha"
texturePickWithAlpha = AttrLabelProxy

texturePixelFormat :: AttrLabelProxy "pixelFormat"
texturePixelFormat = AttrLabelProxy

textureRepeatX :: AttrLabelProxy "repeatX"
textureRepeatX = AttrLabelProxy

textureRepeatY :: AttrLabelProxy "repeatY"
textureRepeatY = AttrLabelProxy

textureSyncSize :: AttrLabelProxy "syncSize"
textureSyncSize = AttrLabelProxy

textureTileWaste :: AttrLabelProxy "tileWaste"
textureTileWaste = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "clutter_texture_new" clutter_texture_new :: 
    IO (Ptr Texture)

{-# DEPRECATED textureNew ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' instead"] #-}
-- | Creates a new empty t'GI.Clutter.Objects.Texture.Texture' object.
textureNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Texture
    -- ^ __Returns:__ A newly created t'GI.Clutter.Objects.Texture.Texture' object.
textureNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Texture
textureNew  = IO Texture -> m Texture
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Texture -> m Texture) -> IO Texture -> m Texture
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
result <- IO (Ptr Texture)
clutter_texture_new
    Text -> Ptr Texture -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textureNew" Ptr Texture
result
    Texture
result' <- ((ManagedPtr Texture -> Texture) -> Ptr Texture -> IO Texture
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Texture -> Texture
Texture) Ptr Texture
result
    Texture -> IO Texture
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Texture
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Texture::new_from_actor
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A source #ClutterActor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Texture" })
-- throws : False
-- Skip return : False

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

{-# DEPRECATED textureNewFromActor ["(Since version 1.8)","Use the t'GI.Clutter.Objects.OffscreenEffect.OffscreenEffect' and t'GI.Clutter.Objects.ShaderEffect.ShaderEffect'","  directly on the intended t'GI.Clutter.Objects.Actor.Actor' to replace the functionality of","  this function."] #-}
-- | Creates a new t'GI.Clutter.Objects.Texture.Texture' object with its source a prexisting
-- actor (and associated children). The textures content will contain
-- \'live\' redirected output of the actors scene.
-- 
-- Note this function is intented as a utility call for uniformly applying
-- shaders to groups and other potential visual effects. It requires that
-- the 'GI.Clutter.Flags.FeatureFlagsOffscreen' feature is supported by the current backend
-- and the target system.
-- 
-- Some tips on usage:
-- 
--   - The source actor must be visible
--   - The source actor must have a parent in order for it to be
--     allocated a size from the layouting mechanism. If the source
--     actor does not have a parent when this function is called then
--     the ClutterTexture will adopt it and allocate it at its
--     preferred size. Using this you can clone an actor that is
--     otherwise not displayed. Because of this feature if you do
--     intend to display the source actor then you must make sure that
--     the actor is parented before calling
--     'GI.Clutter.Objects.Texture.textureNewFromActor' or that you unparent it before
--     adding it to a container.
--   - When getting the image for the clone texture, Clutter
--     will attempt to render the source actor exactly as it would
--     appear if it was rendered on screen. The source actor\'s parent
--     transformations are taken into account. Therefore if your
--     source actor is rotated along the X or Y axes so that it has
--     some depth, the texture will appear differently depending on
--     the on-screen location of the source actor. While painting the
--     source actor, Clutter will set up a temporary asymmetric
--     perspective matrix as the projection matrix so that the source
--     actor will be projected as if a small section of the screen was
--     being viewed. Before version 0.8.2, an orthogonal identity
--     projection was used which meant that the source actor would be
--     clipped if any part of it was not on the zero Z-plane.
--   - Avoid reparenting the source with the created texture.
--   - A group can be padded with a transparent rectangle as to
--     provide a border to contents for shader output (blurring text
--     for example).
--   - The texture will automatically resize to contain a further
--     transformed source. However, this involves overhead and can be
--     avoided by placing the source actor in a bounding group
--     sized large enough to contain any child tranformations.
--   -  Uploading pixel data to the texture (e.g by using
--     'GI.Clutter.Objects.Texture.textureSetFromFile') will destroy the offscreen texture
--     data and end redirection.
--   - 'GI.Cogl.Interfaces.Texture.textureGetData' with the handle returned by
--     'GI.Clutter.Objects.Texture.textureGetCoglTexture' can be used to read the
--     offscreen texture pixels into a pixbuf.
-- 
-- /Since: 0.6/
textureNewFromActor ::
    (B.CallStack.HasCallStack, MonadIO m, Clutter.Actor.IsActor a) =>
    a
    -- ^ /@actor@/: A source t'GI.Clutter.Objects.Actor.Actor'
    -> m Texture
    -- ^ __Returns:__ A newly created t'GI.Clutter.Objects.Texture.Texture' object, or 'P.Nothing' on failure.
textureNewFromActor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
a -> m Texture
textureNewFromActor a
actor = IO Texture -> m Texture
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Texture -> m Texture) -> IO Texture -> m Texture
forall a b. (a -> b) -> a -> b
$ do
    Ptr Actor
actor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
actor
    Ptr Texture
result <- Ptr Actor -> IO (Ptr Texture)
clutter_texture_new_from_actor Ptr Actor
actor'
    Text -> Ptr Texture -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textureNewFromActor" Ptr Texture
result
    Texture
result' <- ((ManagedPtr Texture -> Texture) -> Ptr Texture -> IO Texture
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Texture -> Texture
Texture) Ptr Texture
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
actor
    Texture -> IO Texture
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Texture
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Texture::new_from_file
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "filename"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of an image file to load."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Texture" })
-- throws : True
-- Skip return : False

foreign import ccall "clutter_texture_new_from_file" clutter_texture_new_from_file :: 
    CString ->                              -- filename : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Texture)

{-# DEPRECATED textureNewFromFile ["(Since version 1.12)","No direct replacement is available. Use t'GI.Clutter.Objects.Image.Image'","  and platform-specific image loading API, like GdkPixbuf, instead"] #-}
-- | Creates a new ClutterTexture actor to display the image contained a
-- file. If the image failed to load then NULL is returned and /@error@/
-- is set.
-- 
-- /Since: 0.8/
textureNewFromFile ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@filename@/: The name of an image file to load.
    -> m Texture
    -- ^ __Returns:__ A newly created t'GI.Clutter.Objects.Texture.Texture' object or NULL on
    -- error. /(Can throw 'Data.GI.Base.GError.GError')/
textureNewFromFile :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m Texture
textureNewFromFile Text
filename = IO Texture -> m Texture
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Texture -> m Texture) -> IO Texture -> m Texture
forall a b. (a -> b) -> a -> b
$ do
    CString
filename' <- Text -> IO CString
textToCString Text
filename
    IO Texture -> IO () -> IO Texture
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Texture
result <- (Ptr (Ptr GError) -> IO (Ptr Texture)) -> IO (Ptr Texture)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Texture)) -> IO (Ptr Texture))
-> (Ptr (Ptr GError) -> IO (Ptr Texture)) -> IO (Ptr Texture)
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr Texture)
clutter_texture_new_from_file CString
filename'
        Text -> Ptr Texture -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textureNewFromFile" Ptr Texture
result
        Texture
result' <- ((ManagedPtr Texture -> Texture) -> Ptr Texture -> IO Texture
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Texture -> Texture
Texture) Ptr Texture
result
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
        Texture -> IO Texture
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Texture
result'
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
     )

#if defined(ENABLE_OVERLOADING)
#endif

-- method Texture::get_base_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the width, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the height, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_get_base_size" clutter_texture_get_base_size :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    Ptr Int32 ->                            -- width : TBasicType TInt
    Ptr Int32 ->                            -- height : TBasicType TInt
    IO ()

{-# DEPRECATED textureGetBaseSize ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Interfaces.Content.contentGetPreferredSize'","  instead"] #-}
-- | Gets the size in pixels of the untransformed underlying image
textureGetBaseSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> m ((Int32, Int32))
textureGetBaseSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m (Int32, Int32)
textureGetBaseSize a
texture = IO (Int32, Int32) -> m (Int32, Int32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    Ptr Int32
width <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
height <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Texture -> Ptr Int32 -> Ptr Int32 -> IO ()
clutter_texture_get_base_size Ptr Texture
texture' Ptr Int32
width Ptr Int32
height
    Int32
width' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
width
    Int32
height' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
width
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
    (Int32, Int32) -> IO (Int32, Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
width', Int32
height')

#if defined(ENABLE_OVERLOADING)
data TextureGetBaseSizeMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetBaseSizeMethodInfo a signature where
    overloadedMethod = textureGetBaseSize

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


#endif

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

foreign import ccall "clutter_texture_get_cogl_material" clutter_texture_get_cogl_material :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO (Ptr ())

{-# DEPRECATED textureGetCoglMaterial ["(Since version 1.12)","No replacement is available; it\\'s not advisable","  to modify the Cogl pipeline of an actor. Use a t'GI.Clutter.Interfaces.Content.Content'","  implementation and modify the pipeline during the paint sequence"] #-}
-- | Returns a handle to the underlying COGL material used for drawing
-- the actor.
-- 
-- /Since: 1.0/
textureGetCoglMaterial ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> m (Ptr ())
    -- ^ __Returns:__ a handle for a t'GI.Cogl.Structs.Material.Material'. The
    --   material is owned by the t'GI.Clutter.Objects.Texture.Texture' and it should not be
    --   unreferenced
textureGetCoglMaterial :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m (Ptr ())
textureGetCoglMaterial a
texture = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    Ptr ()
result <- Ptr Texture -> IO (Ptr ())
clutter_texture_get_cogl_material Ptr Texture
texture'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data TextureGetCoglMaterialMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetCoglMaterialMethodInfo a signature where
    overloadedMethod = textureGetCoglMaterial

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


#endif

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

foreign import ccall "clutter_texture_get_cogl_texture" clutter_texture_get_cogl_texture :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO (Ptr ())

{-# DEPRECATED textureGetCoglTexture ["(Since version 1.12)","No replacement available; it\\'s not advisable to","  modify the Cogl pipeline of an actor. Use a t'GI.Clutter.Interfaces.Content.Content'","  implementation and set up the pipeline during the paint sequence","  instead."] #-}
-- | Retrieves the handle to the underlying COGL texture used for drawing
-- the actor. No extra reference is taken so if you need to keep the
-- handle then you should call 'GI.Cogl.Functions.handleRef' on it.
-- 
-- The texture handle returned is the first layer of the material
-- handle used by the t'GI.Clutter.Objects.Texture.Texture'. If you need to access the other
-- layers you should use 'GI.Clutter.Objects.Texture.textureGetCoglMaterial' instead
-- and use the t'GI.Cogl.Structs.Material.Material' API.
-- 
-- /Since: 0.8/
textureGetCoglTexture ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> m (Ptr ())
    -- ^ __Returns:__ a @/CoglHandle/@ for the texture. The returned
    --   handle is owned by the t'GI.Clutter.Objects.Texture.Texture' and it should not be unreferenced
textureGetCoglTexture :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m (Ptr ())
textureGetCoglTexture a
texture = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    Ptr ()
result <- Ptr Texture -> IO (Ptr ())
clutter_texture_get_cogl_texture Ptr Texture
texture'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data TextureGetCoglTextureMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetCoglTextureMethodInfo a signature where
    overloadedMethod = textureGetCoglTexture

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


#endif

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

foreign import ccall "clutter_texture_get_filter_quality" clutter_texture_get_filter_quality :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO CUInt

{-# DEPRECATED textureGetFilterQuality ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Actor.actorGetContentScalingFilters'","  instead"] #-}
-- | Gets the filter quality used when scaling a texture.
-- 
-- /Since: 0.8/
textureGetFilterQuality ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> m Clutter.Enums.TextureQuality
    -- ^ __Returns:__ The filter quality value.
textureGetFilterQuality :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m TextureQuality
textureGetFilterQuality a
texture = IO TextureQuality -> m TextureQuality
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextureQuality -> m TextureQuality)
-> IO TextureQuality -> m TextureQuality
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    CUInt
result <- Ptr Texture -> IO CUInt
clutter_texture_get_filter_quality Ptr Texture
texture'
    let result' :: TextureQuality
result' = (Int -> TextureQuality
forall a. Enum a => Int -> a
toEnum (Int -> TextureQuality)
-> (CUInt -> Int) -> CUInt -> TextureQuality
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    TextureQuality -> IO TextureQuality
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextureQuality
result'

#if defined(ENABLE_OVERLOADING)
data TextureGetFilterQualityMethodInfo
instance (signature ~ (m Clutter.Enums.TextureQuality), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetFilterQualityMethodInfo a signature where
    overloadedMethod = textureGetFilterQuality

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


#endif

-- method Texture::get_keep_aspect_ratio
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , 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_texture_get_keep_aspect_ratio" clutter_texture_get_keep_aspect_ratio :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO CInt

{-# DEPRECATED textureGetKeepAspectRatio ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Actor.actorGetContentGravity'","  instead"] #-}
-- | Retrieves the value set using 'GI.Clutter.Objects.Texture.textureSetKeepAspectRatio'
-- 
-- /Since: 1.0/
textureGetKeepAspectRatio ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Texture.Texture' should maintain the
    --   aspect ratio of the underlying image
textureGetKeepAspectRatio :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m Bool
textureGetKeepAspectRatio a
texture = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    CInt
result <- Ptr Texture -> IO CInt
clutter_texture_get_keep_aspect_ratio Ptr Texture
texture'
    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
texture
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextureGetKeepAspectRatioMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetKeepAspectRatioMethodInfo a signature where
    overloadedMethod = textureGetKeepAspectRatio

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


#endif

-- method Texture::get_load_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , 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_texture_get_load_async" clutter_texture_get_load_async :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO CInt

{-# DEPRECATED textureGetLoadAsync ["(Since version 1.12)","There is no direct replacement for this function"] #-}
-- | Retrieves the value set using 'GI.Clutter.Objects.Texture.textureSetLoadAsync'
-- 
-- /Since: 1.0/
textureGetLoadAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Texture.Texture' should load the data from
    --   disk asynchronously
textureGetLoadAsync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m Bool
textureGetLoadAsync a
texture = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    CInt
result <- Ptr Texture -> IO CInt
clutter_texture_get_load_async Ptr Texture
texture'
    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
texture
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextureGetLoadAsyncMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetLoadAsyncMethodInfo a signature where
    overloadedMethod = textureGetLoadAsync

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


#endif

-- method Texture::get_load_data_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , 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_texture_get_load_data_async" clutter_texture_get_load_data_async :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO CInt

{-# DEPRECATED textureGetLoadDataAsync ["(Since version 1.12)","There is no direct replacement for this function"] #-}
-- | Retrieves the value set by 'GI.Clutter.Objects.Texture.textureSetLoadDataAsync'
-- 
-- /Since: 1.0/
textureGetLoadDataAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Texture.Texture' should load the image
    --   data from a file asynchronously
textureGetLoadDataAsync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m Bool
textureGetLoadDataAsync a
texture = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    CInt
result <- Ptr Texture -> IO CInt
clutter_texture_get_load_data_async Ptr Texture
texture'
    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
texture
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextureGetLoadDataAsyncMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetLoadDataAsyncMethodInfo a signature where
    overloadedMethod = textureGetLoadDataAsync

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


#endif

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

foreign import ccall "clutter_texture_get_max_tile_waste" clutter_texture_get_max_tile_waste :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO Int32

{-# DEPRECATED textureGetMaxTileWaste ["(Since version 1.12)","No replacement is available"] #-}
-- | Gets the maximum waste that will be used when creating a texture or
-- -1 if slicing is disabled.
-- 
-- /Since: 0.8/
textureGetMaxTileWaste ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> m Int32
    -- ^ __Returns:__ The maximum waste or -1 if the texture waste is
    --   unlimited.
textureGetMaxTileWaste :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m Int32
textureGetMaxTileWaste a
texture = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    Int32
result <- Ptr Texture -> IO Int32
clutter_texture_get_max_tile_waste Ptr Texture
texture'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TextureGetMaxTileWasteMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetMaxTileWasteMethodInfo a signature where
    overloadedMethod = textureGetMaxTileWaste

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


#endif

-- method Texture::get_pick_with_alpha
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , 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_texture_get_pick_with_alpha" clutter_texture_get_pick_with_alpha :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO CInt

{-# DEPRECATED textureGetPickWithAlpha ["(Since version 1.12)","There is no direct replacement for this function"] #-}
-- | Retrieves the value set by 'GI.Clutter.Objects.Texture.textureSetLoadDataAsync'
-- 
-- /Since: 1.4/
textureGetPickWithAlpha ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Texture.Texture' should define its shape
    -- using the alpha channel when picking.
textureGetPickWithAlpha :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m Bool
textureGetPickWithAlpha a
texture = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    CInt
result <- Ptr Texture -> IO CInt
clutter_texture_get_pick_with_alpha Ptr Texture
texture'
    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
texture
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextureGetPickWithAlphaMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetPickWithAlphaMethodInfo a signature where
    overloadedMethod = textureGetPickWithAlpha

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


#endif

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

foreign import ccall "clutter_texture_get_pixel_format" clutter_texture_get_pixel_format :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO CUInt

{-# DEPRECATED textureGetPixelFormat ["(Since version 1.12)","There is no direct replacement for this function"] #-}
-- | Retrieves the pixel format used by /@texture@/. This is
-- equivalent to:
-- 
-- >
-- >  handle = clutter_texture_get_pixel_format (texture);
-- >
-- >  if (handle != COGL_INVALID_HANDLE)
-- >    format = cogl_texture_get_format (handle);
-- 
-- 
-- /Since: 1.0/
textureGetPixelFormat ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> m Cogl.Enums.PixelFormat
    -- ^ __Returns:__ a t'GI.Cogl.Enums.PixelFormat' value
textureGetPixelFormat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m PixelFormat
textureGetPixelFormat a
texture = IO PixelFormat -> m PixelFormat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PixelFormat -> m PixelFormat)
-> IO PixelFormat -> m PixelFormat
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    CUInt
result <- Ptr Texture -> IO CUInt
clutter_texture_get_pixel_format Ptr Texture
texture'
    let result' :: PixelFormat
result' = (Int -> PixelFormat
forall a. Enum a => Int -> a
toEnum (Int -> PixelFormat) -> (CUInt -> Int) -> CUInt -> PixelFormat
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    PixelFormat -> IO PixelFormat
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PixelFormat
result'

#if defined(ENABLE_OVERLOADING)
data TextureGetPixelFormatMethodInfo
instance (signature ~ (m Cogl.Enums.PixelFormat), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetPixelFormatMethodInfo a signature where
    overloadedMethod = textureGetPixelFormat

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


#endif

-- method Texture::get_repeat
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "repeat_x"
--           , argType = TBasicType TBoolean
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the horizontal repeat"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "repeat_y"
--           , argType = TBasicType TBoolean
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the vertical repeat"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_get_repeat" clutter_texture_get_repeat :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    Ptr CInt ->                             -- repeat_x : TBasicType TBoolean
    Ptr CInt ->                             -- repeat_y : TBasicType TBoolean
    IO ()

{-# DEPRECATED textureGetRepeat ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Actor.actorGetContentRepeat'","  instead"] #-}
-- | Retrieves the horizontal and vertical repeat values set
-- using 'GI.Clutter.Objects.Texture.textureSetRepeat'
-- 
-- /Since: 1.0/
textureGetRepeat ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> m ((Bool, Bool))
textureGetRepeat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m (Bool, Bool)
textureGetRepeat a
texture = IO (Bool, Bool) -> m (Bool, Bool)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Bool) -> m (Bool, Bool))
-> IO (Bool, Bool) -> m (Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    Ptr CInt
repeatX <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    Ptr CInt
repeatY <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    Ptr Texture -> Ptr CInt -> Ptr CInt -> IO ()
clutter_texture_get_repeat Ptr Texture
texture' Ptr CInt
repeatX Ptr CInt
repeatY
    CInt
repeatX' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
repeatX
    let repeatX'' :: Bool
repeatX'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
repeatX'
    CInt
repeatY' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
repeatY
    let repeatY'' :: Bool
repeatY'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
repeatY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
repeatX
    Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
repeatY
    (Bool, Bool) -> IO (Bool, Bool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
repeatX'', Bool
repeatY'')

#if defined(ENABLE_OVERLOADING)
data TextureGetRepeatMethodInfo
instance (signature ~ (m ((Bool, Bool))), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetRepeatMethodInfo a signature where
    overloadedMethod = textureGetRepeat

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


#endif

-- method Texture::get_sync_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , 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_texture_get_sync_size" clutter_texture_get_sync_size :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    IO CInt

{-# DEPRECATED textureGetSyncSize ["(Since version 1.12)","There is no direct replacement"] #-}
-- | Retrieves the value set with 'GI.Clutter.Objects.Texture.textureSetSyncSize'
-- 
-- /Since: 1.0/
textureGetSyncSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Texture.Texture' should have the same
    --   preferred size of the underlying image data
textureGetSyncSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> m Bool
textureGetSyncSize a
texture = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    CInt
result <- Ptr Texture -> IO CInt
clutter_texture_get_sync_size Ptr Texture
texture'
    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
texture
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextureGetSyncSizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTexture a) => O.OverloadedMethod TextureGetSyncSizeMethodInfo a signature where
    overloadedMethod = textureGetSyncSize

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


#endif

-- method Texture::set_area_from_rgb_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TCArray False (-1) (-1) (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Image data in RGB type colorspace."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "has_alpha"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Set to TRUE if image data has an alpha channel."
--                 , 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 of upper left corner of region to update."
--                 , 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 of upper left corner of region to update."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Width in pixels of region to update."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Height in pixels of region to update."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rowstride"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Distance in bytes between row starts on source buffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bpp"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "bytes per pixel (Currently only 3 and 4 supported,\n                       depending on @has_alpha)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "TextureFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#ClutterTextureFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "clutter_texture_set_area_from_rgb_data" clutter_texture_set_area_from_rgb_data :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    Ptr Word8 ->                            -- data : TCArray False (-1) (-1) (TBasicType TUInt8)
    CInt ->                                 -- has_alpha : TBasicType TBoolean
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    Int32 ->                                -- rowstride : TBasicType TInt
    Int32 ->                                -- bpp : TBasicType TInt
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "TextureFlags"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED textureSetAreaFromRgbData ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Image.imageSetArea' instead"] #-}
-- | Updates a sub-region of the pixel data in a t'GI.Clutter.Objects.Texture.Texture'.
-- 
-- /Since: 0.6/
textureSetAreaFromRgbData ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> Ptr Word8
    -- ^ /@data@/: Image data in RGB type colorspace.
    -> Bool
    -- ^ /@hasAlpha@/: Set to TRUE if image data has an alpha channel.
    -> Int32
    -- ^ /@x@/: X coordinate of upper left corner of region to update.
    -> Int32
    -- ^ /@y@/: Y coordinate of upper left corner of region to update.
    -> Int32
    -- ^ /@width@/: Width in pixels of region to update.
    -> Int32
    -- ^ /@height@/: Height in pixels of region to update.
    -> Int32
    -- ^ /@rowstride@/: Distance in bytes between row starts on source buffer.
    -> Int32
    -- ^ /@bpp@/: bytes per pixel (Currently only 3 and 4 supported,
    --                        depending on /@hasAlpha@/)
    -> [Clutter.Flags.TextureFlags]
    -- ^ /@flags@/: t'GI.Clutter.Flags.TextureFlags'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
textureSetAreaFromRgbData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a
-> Ptr Word8
-> Bool
-> Int32
-> Int32
-> Int32
-> Int32
-> Int32
-> Int32
-> [TextureFlags]
-> m ()
textureSetAreaFromRgbData a
texture Ptr Word8
data_ Bool
hasAlpha Int32
x Int32
y Int32
width Int32
height Int32
rowstride Int32
bpp [TextureFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let hasAlpha' :: CInt
hasAlpha' = (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
hasAlpha
    let flags' :: CUInt
flags' = [TextureFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TextureFlags]
flags
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Texture
-> Ptr Word8
-> CInt
-> Int32
-> Int32
-> Int32
-> Int32
-> Int32
-> Int32
-> CUInt
-> Ptr (Ptr GError)
-> IO CInt
clutter_texture_set_area_from_rgb_data Ptr Texture
texture' Ptr Word8
data_ CInt
hasAlpha' Int32
x Int32
y Int32
width Int32
height Int32
rowstride Int32
bpp CUInt
flags'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TextureSetAreaFromRgbDataMethodInfo
instance (signature ~ (Ptr Word8 -> Bool -> Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> [Clutter.Flags.TextureFlags] -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetAreaFromRgbDataMethodInfo a signature where
    overloadedMethod = textureSetAreaFromRgbData

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


#endif

-- method Texture::set_cogl_material
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cogl_material"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A CoglHandle for a material"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_cogl_material" clutter_texture_set_cogl_material :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    Ptr () ->                               -- cogl_material : TBasicType TPtr
    IO ()

{-# DEPRECATED textureSetCoglMaterial ["(Since version 1.12)","No replacement is available; it\\'s not advisable","  to modify the Cogl pipeline of an actor. Use a t'GI.Clutter.Interfaces.Content.Content'","  implementation and modify the pipeline during the paint sequence"] #-}
-- | Replaces the underlying Cogl material drawn by this actor with
-- /@coglMaterial@/. A reference to the material is taken so if the
-- handle is no longer needed it should be deref\'d with
-- cogl_handle_unref. Texture data is attached to the material so
-- calling this function also replaces the Cogl
-- texture. t'GI.Clutter.Objects.Texture.Texture' requires that the material have a texture
-- layer so you should set one on the material before calling this
-- function.
-- 
-- /Since: 0.8/
textureSetCoglMaterial ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> Ptr ()
    -- ^ /@coglMaterial@/: A CoglHandle for a material
    -> m ()
textureSetCoglMaterial :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Ptr () -> m ()
textureSetCoglMaterial a
texture Ptr ()
coglMaterial = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    C_TexturePixbufChangeCallback
clutter_texture_set_cogl_material Ptr Texture
texture' Ptr ()
coglMaterial
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetCoglMaterialMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetCoglMaterialMethodInfo a signature where
    overloadedMethod = textureSetCoglMaterial

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


#endif

-- method Texture::set_cogl_texture
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cogl_tex"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A CoglHandle for a texture"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_cogl_texture" clutter_texture_set_cogl_texture :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    Ptr () ->                               -- cogl_tex : TBasicType TPtr
    IO ()

{-# DEPRECATED textureSetCoglTexture ["(Since version 1.12)","No replacement available; it\\'s not advisable to","  modify the Cogl pipeline of an actor. Use a t'GI.Clutter.Interfaces.Content.Content'","  implementation and set up the pipeline during the paint sequence","  instead."] #-}
-- | Replaces the underlying COGL texture drawn by this actor with
-- /@coglTex@/. A reference to the texture is taken so if the handle is
-- no longer needed it should be deref\'d with cogl_handle_unref.
-- 
-- /Since: 0.8/
textureSetCoglTexture ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> Ptr ()
    -- ^ /@coglTex@/: A CoglHandle for a texture
    -> m ()
textureSetCoglTexture :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Ptr () -> m ()
textureSetCoglTexture a
texture Ptr ()
coglTex = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    C_TexturePixbufChangeCallback
clutter_texture_set_cogl_texture Ptr Texture
texture' Ptr ()
coglTex
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetCoglTextureMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetCoglTextureMethodInfo a signature where
    overloadedMethod = textureSetCoglTexture

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


#endif

-- method Texture::set_filter_quality
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filter_quality"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "TextureQuality" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "new filter quality value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_filter_quality" clutter_texture_set_filter_quality :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    CUInt ->                                -- filter_quality : TInterface (Name {namespace = "Clutter", name = "TextureQuality"})
    IO ()

{-# DEPRECATED textureSetFilterQuality ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Actor.actorSetContentScalingFilters'","  instead"] #-}
-- | Sets the filter quality when scaling a texture. The quality is an
-- enumeration currently the following values are supported:
-- 'GI.Clutter.Enums.TextureQualityLow' which is fast but only uses nearest neighbour
-- interpolation. 'GI.Clutter.Enums.TextureQualityMedium' which is computationally a
-- bit more expensive (bilinear interpolation), and
-- 'GI.Clutter.Enums.TextureQualityHigh' which uses extra texture memory resources to
-- improve scaled down rendering as well (by using mipmaps). The default value
-- is 'GI.Clutter.Enums.TextureQualityMedium'.
-- 
-- /Since: 0.8/
textureSetFilterQuality ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> Clutter.Enums.TextureQuality
    -- ^ /@filterQuality@/: new filter quality value
    -> m ()
textureSetFilterQuality :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> TextureQuality -> m ()
textureSetFilterQuality a
texture TextureQuality
filterQuality = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let filterQuality' :: CUInt
filterQuality' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (TextureQuality -> Int) -> TextureQuality -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextureQuality -> Int
forall a. Enum a => a -> Int
fromEnum) TextureQuality
filterQuality
    Ptr Texture -> CUInt -> IO ()
clutter_texture_set_filter_quality Ptr Texture
texture' CUInt
filterQuality'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetFilterQualityMethodInfo
instance (signature ~ (Clutter.Enums.TextureQuality -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetFilterQualityMethodInfo a signature where
    overloadedMethod = textureSetFilterQuality

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


#endif

-- method Texture::set_from_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filename"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The filename of the image in GLib file name encoding"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "clutter_texture_set_from_file" clutter_texture_set_from_file :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    CString ->                              -- filename : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED textureSetFromFile ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and platform-specific image","  loading API, like GdkPixbuf, instead"] #-}
-- | Sets the t'GI.Clutter.Objects.Texture.Texture' image data from an image file. In case of
-- failure, 'P.False' is returned and /@error@/ is set.
-- 
-- If [Texture:loadAsync]("GI.Clutter.Objects.Texture#g:attr:loadAsync") is set to 'P.True', this function
-- will return as soon as possible, and the actual image loading
-- from disk will be performed asynchronously. [Texture::sizeChange]("GI.Clutter.Objects.Texture#g:signal:sizeChange")
-- will be emitten when the size of the texture is available and
-- [Texture::loadFinished]("GI.Clutter.Objects.Texture#g:signal:loadFinished") will be emitted when the image has been
-- loaded or if an error occurred.
-- 
-- /Since: 0.8/
textureSetFromFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> T.Text
    -- ^ /@filename@/: The filename of the image in GLib file name encoding
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
textureSetFromFile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Text -> m ()
textureSetFromFile a
texture Text
filename = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    CString
filename' <- Text -> IO CString
textToCString Text
filename
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Texture -> CString -> Ptr (Ptr GError) -> IO CInt
clutter_texture_set_from_file Ptr Texture
texture' CString
filename'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
     )

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

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


#endif

-- method Texture::set_from_rgb_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TCArray False (-1) (-1) (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "image data in RGBA type colorspace."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "has_alpha"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "set to %TRUE if image data has an alpha channel."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "width in pixels of image data."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "height in pixels of image data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rowstride"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "distance in bytes between row starts."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bpp"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "bytes per pixel (currently only 3 and 4 supported, depending\n  on the value of @has_alpha)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "TextureFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#ClutterTextureFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "clutter_texture_set_from_rgb_data" clutter_texture_set_from_rgb_data :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    Ptr Word8 ->                            -- data : TCArray False (-1) (-1) (TBasicType TUInt8)
    CInt ->                                 -- has_alpha : TBasicType TBoolean
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    Int32 ->                                -- rowstride : TBasicType TInt
    Int32 ->                                -- bpp : TBasicType TInt
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "TextureFlags"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED textureSetFromRgbData ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Image.imageSetData' instead"] #-}
-- | Sets t'GI.Clutter.Objects.Texture.Texture' image data.
-- 
-- /Since: 0.4/
textureSetFromRgbData ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> Ptr Word8
    -- ^ /@data@/: image data in RGBA type colorspace.
    -> Bool
    -- ^ /@hasAlpha@/: set to 'P.True' if image data has an alpha channel.
    -> Int32
    -- ^ /@width@/: width in pixels of image data.
    -> Int32
    -- ^ /@height@/: height in pixels of image data
    -> Int32
    -- ^ /@rowstride@/: distance in bytes between row starts.
    -> Int32
    -- ^ /@bpp@/: bytes per pixel (currently only 3 and 4 supported, depending
    --   on the value of /@hasAlpha@/)
    -> [Clutter.Flags.TextureFlags]
    -- ^ /@flags@/: t'GI.Clutter.Flags.TextureFlags'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
textureSetFromRgbData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a
-> Ptr Word8
-> Bool
-> Int32
-> Int32
-> Int32
-> Int32
-> [TextureFlags]
-> m ()
textureSetFromRgbData a
texture Ptr Word8
data_ Bool
hasAlpha Int32
width Int32
height Int32
rowstride Int32
bpp [TextureFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let hasAlpha' :: CInt
hasAlpha' = (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
hasAlpha
    let flags' :: CUInt
flags' = [TextureFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TextureFlags]
flags
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Texture
-> Ptr Word8
-> CInt
-> Int32
-> Int32
-> Int32
-> Int32
-> CUInt
-> Ptr (Ptr GError)
-> IO CInt
clutter_texture_set_from_rgb_data Ptr Texture
texture' Ptr Word8
data_ CInt
hasAlpha' Int32
width Int32
height Int32
rowstride Int32
bpp CUInt
flags'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TextureSetFromRgbDataMethodInfo
instance (signature ~ (Ptr Word8 -> Bool -> Int32 -> Int32 -> Int32 -> Int32 -> [Clutter.Flags.TextureFlags] -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetFromRgbDataMethodInfo a signature where
    overloadedMethod = textureSetFromRgbData

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


#endif

-- method Texture::set_from_yuv_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TCArray False (-1) (-1) (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Image data in YUV type colorspace."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Width in pixels of image data."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Height in pixels of image data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "TextureFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#ClutterTextureFlags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "clutter_texture_set_from_yuv_data" clutter_texture_set_from_yuv_data :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    Ptr Word8 ->                            -- data : TCArray False (-1) (-1) (TBasicType TUInt8)
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "TextureFlags"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED textureSetFromYuvData ["(Since version 1.10)","Use a custom t'GI.Clutter.Interfaces.Content.Content' implementation and","  set up the Cogl pipeline using a t'GI.Clutter.Objects.PipelineNode.PipelineNode' with a","  fragment shader instead."] #-}
-- | Sets a t'GI.Clutter.Objects.Texture.Texture' from YUV image data. If an error occurred,
-- 'P.False' is returned and /@error@/ is set.
-- 
-- The YUV support depends on the driver; the format supported by the
-- few drivers exposing this capability are not really useful.
-- 
-- The proper way to convert image data in any YUV colorspace to any
-- RGB colorspace is to use a fragment shader associated with the
-- t'GI.Clutter.Objects.Texture.Texture' material.
-- 
-- /Since: 0.4/
textureSetFromYuvData ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: A t'GI.Clutter.Objects.Texture.Texture'
    -> Ptr Word8
    -- ^ /@data@/: Image data in YUV type colorspace.
    -> Int32
    -- ^ /@width@/: Width in pixels of image data.
    -> Int32
    -- ^ /@height@/: Height in pixels of image data
    -> [Clutter.Flags.TextureFlags]
    -- ^ /@flags@/: t'GI.Clutter.Flags.TextureFlags'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
textureSetFromYuvData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Ptr Word8 -> Int32 -> Int32 -> [TextureFlags] -> m ()
textureSetFromYuvData a
texture Ptr Word8
data_ Int32
width Int32
height [TextureFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let flags' :: CUInt
flags' = [TextureFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TextureFlags]
flags
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Texture
-> Ptr Word8
-> Int32
-> Int32
-> CUInt
-> Ptr (Ptr GError)
-> IO CInt
clutter_texture_set_from_yuv_data Ptr Texture
texture' Ptr Word8
data_ Int32
width Int32
height CUInt
flags'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TextureSetFromYuvDataMethodInfo
instance (signature ~ (Ptr Word8 -> Int32 -> Int32 -> [Clutter.Flags.TextureFlags] -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetFromYuvDataMethodInfo a signature where
    overloadedMethod = textureSetFromYuvData

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


#endif

-- method Texture::set_keep_aspect_ratio
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keep_aspect"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to maintain aspect ratio"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_keep_aspect_ratio" clutter_texture_set_keep_aspect_ratio :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    CInt ->                                 -- keep_aspect : TBasicType TBoolean
    IO ()

{-# DEPRECATED textureSetKeepAspectRatio ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Actor.actorSetContentGravity'","  with 'GI.Clutter.Enums.ContentGravityResizeAspect' instead"] #-}
-- | Sets whether /@texture@/ should have a preferred size maintaining
-- the aspect ratio of the underlying image
-- 
-- /Since: 1.0/
textureSetKeepAspectRatio ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> Bool
    -- ^ /@keepAspect@/: 'P.True' to maintain aspect ratio
    -> m ()
textureSetKeepAspectRatio :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Bool -> m ()
textureSetKeepAspectRatio a
texture Bool
keepAspect = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let keepAspect' :: CInt
keepAspect' = (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
keepAspect
    Ptr Texture -> CInt -> IO ()
clutter_texture_set_keep_aspect_ratio Ptr Texture
texture' CInt
keepAspect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetKeepAspectRatioMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetKeepAspectRatioMethodInfo a signature where
    overloadedMethod = textureSetKeepAspectRatio

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


#endif

-- method Texture::set_load_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "load_async"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%TRUE if the texture should asynchronously load data\n  from a filename"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_load_async" clutter_texture_set_load_async :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    CInt ->                                 -- load_async : TBasicType TBoolean
    IO ()

{-# DEPRECATED textureSetLoadAsync ["(Since version 1.12)","There is no direct replacement for this function.","  Use t'GI.Clutter.Objects.Image.Image' and platform-specific API for loading image data","  asynchronously, like GdkPixbuf"] #-}
-- | Sets whether /@texture@/ should use a worker thread to load the data
-- from disk asynchronously. Setting /@loadAsync@/ to 'P.True' will make
-- 'GI.Clutter.Objects.Texture.textureSetFromFile' return immediately.
-- 
-- See the [Texture:loadAsync]("GI.Clutter.Objects.Texture#g:attr:loadAsync") property documentation, and
-- 'GI.Clutter.Objects.Texture.textureSetLoadDataAsync'.
-- 
-- /Since: 1.0/
textureSetLoadAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> Bool
    -- ^ /@loadAsync@/: 'P.True' if the texture should asynchronously load data
    --   from a filename
    -> m ()
textureSetLoadAsync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Bool -> m ()
textureSetLoadAsync a
texture Bool
loadAsync = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let loadAsync' :: CInt
loadAsync' = (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
loadAsync
    Ptr Texture -> CInt -> IO ()
clutter_texture_set_load_async Ptr Texture
texture' CInt
loadAsync'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetLoadAsyncMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetLoadAsyncMethodInfo a signature where
    overloadedMethod = textureSetLoadAsync

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


#endif

-- method Texture::set_load_data_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "load_async"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%TRUE if the texture should asynchronously load data\n  from a filename"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_load_data_async" clutter_texture_set_load_data_async :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    CInt ->                                 -- load_async : TBasicType TBoolean
    IO ()

{-# DEPRECATED textureSetLoadDataAsync ["(Since version 1.12)","There is no direct replacement for this function.","  Use t'GI.Clutter.Objects.Image.Image' and platform-specific API for loading image data","  asynchronously, like GdkPixbuf"] #-}
-- | Sets whether /@texture@/ should use a worker thread to load the data
-- from disk asynchronously. Setting /@loadAsync@/ to 'P.True' will make
-- 'GI.Clutter.Objects.Texture.textureSetFromFile' block until the t'GI.Clutter.Objects.Texture.Texture' has
-- determined the width and height of the image data.
-- 
-- See the [Texture:loadAsync]("GI.Clutter.Objects.Texture#g:attr:loadAsync") property documentation, and
-- 'GI.Clutter.Objects.Texture.textureSetLoadAsync'.
-- 
-- /Since: 1.0/
textureSetLoadDataAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> Bool
    -- ^ /@loadAsync@/: 'P.True' if the texture should asynchronously load data
    --   from a filename
    -> m ()
textureSetLoadDataAsync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Bool -> m ()
textureSetLoadDataAsync a
texture Bool
loadAsync = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let loadAsync' :: CInt
loadAsync' = (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
loadAsync
    Ptr Texture -> CInt -> IO ()
clutter_texture_set_load_data_async Ptr Texture
texture' CInt
loadAsync'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetLoadDataAsyncMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetLoadDataAsyncMethodInfo a signature where
    overloadedMethod = textureSetLoadDataAsync

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


#endif

-- method Texture::set_pick_with_alpha
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pick_with_alpha"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%TRUE if the alpha channel should affect the\n  picking shape"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_pick_with_alpha" clutter_texture_set_pick_with_alpha :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    CInt ->                                 -- pick_with_alpha : TBasicType TBoolean
    IO ()

{-# DEPRECATED textureSetPickWithAlpha ["(Since version 1.12)","There is no direct replacement for this function"] #-}
-- | Sets whether /@texture@/ should have it\'s shape defined by the alpha
-- channel when picking.
-- 
-- Be aware that this is a bit more costly than the default picking
-- due to the texture lookup, extra test against the alpha value and
-- the fact that it will also interrupt the batching of geometry done
-- internally.
-- 
-- Also there is currently no control over the threshold used to
-- determine what value of alpha is considered pickable, and so only
-- fully opaque parts of the texture will react to picking.
-- 
-- /Since: 1.4/
textureSetPickWithAlpha ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> Bool
    -- ^ /@pickWithAlpha@/: 'P.True' if the alpha channel should affect the
    --   picking shape
    -> m ()
textureSetPickWithAlpha :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Bool -> m ()
textureSetPickWithAlpha a
texture Bool
pickWithAlpha = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let pickWithAlpha' :: CInt
pickWithAlpha' = (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
pickWithAlpha
    Ptr Texture -> CInt -> IO ()
clutter_texture_set_pick_with_alpha Ptr Texture
texture' CInt
pickWithAlpha'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetPickWithAlphaMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetPickWithAlphaMethodInfo a signature where
    overloadedMethod = textureSetPickWithAlpha

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


#endif

-- method Texture::set_repeat
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "repeat_x"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if the texture should repeat horizontally"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "repeat_y"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the texture should repeat vertically"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_repeat" clutter_texture_set_repeat :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    CInt ->                                 -- repeat_x : TBasicType TBoolean
    CInt ->                                 -- repeat_y : TBasicType TBoolean
    IO ()

{-# DEPRECATED textureSetRepeat ["(Since version 1.12)","Use t'GI.Clutter.Objects.Image.Image' and 'GI.Clutter.Objects.Actor.actorSetContentRepeat'","  instead"] #-}
-- | Sets whether the /@texture@/ should repeat horizontally or
-- vertically when the actor size is bigger than the image size
-- 
-- /Since: 1.0/
textureSetRepeat ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> Bool
    -- ^ /@repeatX@/: 'P.True' if the texture should repeat horizontally
    -> Bool
    -- ^ /@repeatY@/: 'P.True' if the texture should repeat vertically
    -> m ()
textureSetRepeat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Bool -> Bool -> m ()
textureSetRepeat a
texture Bool
repeatX Bool
repeatY = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let repeatX' :: CInt
repeatX' = (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
repeatX
    let repeatY' :: CInt
repeatY' = (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
repeatY
    Ptr Texture -> CInt -> CInt -> IO ()
clutter_texture_set_repeat Ptr Texture
texture' CInt
repeatX' CInt
repeatY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetRepeatMethodInfo
instance (signature ~ (Bool -> Bool -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetRepeatMethodInfo a signature where
    overloadedMethod = textureSetRepeat

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


#endif

-- method Texture::set_sync_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sync_size"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%TRUE if the texture should have the same size of the\n   underlying image data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_texture_set_sync_size" clutter_texture_set_sync_size :: 
    Ptr Texture ->                          -- texture : TInterface (Name {namespace = "Clutter", name = "Texture"})
    CInt ->                                 -- sync_size : TBasicType TBoolean
    IO ()

{-# DEPRECATED textureSetSyncSize ["(Since version 1.12)","No replacement is available. A t'GI.Clutter.Objects.Actor.Actor' using","  t'GI.Clutter.Objects.Image.Image' with a 'GI.Clutter.Enums.RequestModeContentSize' request mode","  will automatically bind the preferred size of the content to the","  preferred size of the actor"] #-}
-- | Sets whether /@texture@/ should have the same preferred size as the
-- underlying image data.
-- 
-- /Since: 1.0/
textureSetSyncSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTexture a) =>
    a
    -- ^ /@texture@/: a t'GI.Clutter.Objects.Texture.Texture'
    -> Bool
    -- ^ /@syncSize@/: 'P.True' if the texture should have the same size of the
    --    underlying image data
    -> m ()
textureSetSyncSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTexture a) =>
a -> Bool -> m ()
textureSetSyncSize a
texture Bool
syncSize = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    let syncSize' :: CInt
syncSize' = (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
syncSize
    Ptr Texture -> CInt -> IO ()
clutter_texture_set_sync_size Ptr Texture
texture' CInt
syncSize'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextureSetSyncSizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTexture a) => O.OverloadedMethod TextureSetSyncSizeMethodInfo a signature where
    overloadedMethod = textureSetSyncSize

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


#endif