{-# 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.Text.Text' struct contains only private data.
-- 
-- /Since: 1.0/

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

module GI.Clutter.Objects.Text
    ( 

-- * Exported types
    Text(..)                                ,
    IsText                                  ,
    toText                                  ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Clutter.Objects.Text#g:method:activate"), [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"), [coordsToPosition]("GI.Clutter.Objects.Text#g:method:coordsToPosition"), [createChildMeta]("GI.Clutter.Interfaces.Container#g:method:createChildMeta"), [createPangoContext]("GI.Clutter.Objects.Actor#g:method:createPangoContext"), [createPangoLayout]("GI.Clutter.Objects.Actor#g:method:createPangoLayout"), [deleteChars]("GI.Clutter.Objects.Text#g:method:deleteChars"), [deleteSelection]("GI.Clutter.Objects.Text#g:method:deleteSelection"), [deleteText]("GI.Clutter.Objects.Text#g:method:deleteText"), [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"), [insertText]("GI.Clutter.Objects.Text#g:method:insertText"), [insertUnichar]("GI.Clutter.Objects.Text#g:method:insertUnichar"), [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"), [positionToCoords]("GI.Clutter.Objects.Text#g:method:positionToCoords"), [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"), [getActivatable]("GI.Clutter.Objects.Text#g:method:getActivatable"), [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"), [getAttributes]("GI.Clutter.Objects.Text#g:method:getAttributes"), [getBackgroundColor]("GI.Clutter.Objects.Actor#g:method:getBackgroundColor"), [getBuffer]("GI.Clutter.Objects.Text#g:method:getBuffer"), [getChars]("GI.Clutter.Objects.Text#g:method:getChars"), [getChildAtIndex]("GI.Clutter.Objects.Actor#g:method:getChildAtIndex"), [getChildMeta]("GI.Clutter.Interfaces.Container#g:method:getChildMeta"), [getChildTransform]("GI.Clutter.Objects.Actor#g:method:getChildTransform"), [getChildren]("GI.Clutter.Objects.Actor#g:method:getChildren"), [getClip]("GI.Clutter.Objects.Actor#g:method:getClip"), [getClipToAllocation]("GI.Clutter.Objects.Actor#g:method:getClipToAllocation"), [getColor]("GI.Clutter.Objects.Text#g:method:getColor"), [getConstraint]("GI.Clutter.Objects.Actor#g:method:getConstraint"), [getConstraints]("GI.Clutter.Objects.Actor#g:method:getConstraints"), [getContent]("GI.Clutter.Objects.Actor#g:method:getContent"), [getContentBox]("GI.Clutter.Objects.Actor#g:method:getContentBox"), [getContentGravity]("GI.Clutter.Objects.Actor#g:method:getContentGravity"), [getContentRepeat]("GI.Clutter.Objects.Actor#g:method:getContentRepeat"), [getContentScalingFilters]("GI.Clutter.Objects.Actor#g:method:getContentScalingFilters"), [getCursorColor]("GI.Clutter.Objects.Text#g:method:getCursorColor"), [getCursorPosition]("GI.Clutter.Objects.Text#g:method:getCursorPosition"), [getCursorRect]("GI.Clutter.Objects.Text#g:method:getCursorRect"), [getCursorSize]("GI.Clutter.Objects.Text#g:method:getCursorSize"), [getCursorVisible]("GI.Clutter.Objects.Text#g:method:getCursorVisible"), [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"), [getEditable]("GI.Clutter.Objects.Text#g:method:getEditable"), [getEffect]("GI.Clutter.Objects.Actor#g:method:getEffect"), [getEffects]("GI.Clutter.Objects.Actor#g:method:getEffects"), [getEllipsize]("GI.Clutter.Objects.Text#g:method:getEllipsize"), [getFirstChild]("GI.Clutter.Objects.Actor#g:method:getFirstChild"), [getFixedPositionSet]("GI.Clutter.Objects.Actor#g:method:getFixedPositionSet"), [getFlags]("GI.Clutter.Objects.Actor#g:method:getFlags"), [getFontDescription]("GI.Clutter.Objects.Text#g:method:getFontDescription"), [getFontName]("GI.Clutter.Objects.Text#g:method:getFontName"), [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"), [getJustify]("GI.Clutter.Objects.Text#g:method:getJustify"), [getLastChild]("GI.Clutter.Objects.Actor#g:method:getLastChild"), [getLayout]("GI.Clutter.Objects.Text#g:method:getLayout"), [getLayoutManager]("GI.Clutter.Objects.Actor#g:method:getLayoutManager"), [getLayoutOffsets]("GI.Clutter.Objects.Text#g:method:getLayoutOffsets"), [getLineAlignment]("GI.Clutter.Objects.Text#g:method:getLineAlignment"), [getLineWrap]("GI.Clutter.Objects.Text#g:method:getLineWrap"), [getLineWrapMode]("GI.Clutter.Objects.Text#g:method:getLineWrapMode"), [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"), [getMaxLength]("GI.Clutter.Objects.Text#g:method:getMaxLength"), [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"), [getPasswordChar]("GI.Clutter.Objects.Text#g:method:getPasswordChar"), [getPivotPoint]("GI.Clutter.Objects.Actor#g:method:getPivotPoint"), [getPivotPointZ]("GI.Clutter.Objects.Actor#g:method:getPivotPointZ"), [getPosition]("GI.Clutter.Objects.Actor#g:method:getPosition"), [getPreferredHeight]("GI.Clutter.Objects.Actor#g:method:getPreferredHeight"), [getPreferredSize]("GI.Clutter.Objects.Actor#g:method:getPreferredSize"), [getPreferredWidth]("GI.Clutter.Objects.Actor#g:method:getPreferredWidth"), [getPreviousSibling]("GI.Clutter.Objects.Actor#g:method:getPreviousSibling"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getReactive]("GI.Clutter.Objects.Actor#g:method:getReactive"), [getRequestMode]("GI.Clutter.Objects.Actor#g:method:getRequestMode"), [getRotation]("GI.Clutter.Objects.Actor#g:method:getRotation"), [getRotationAngle]("GI.Clutter.Objects.Actor#g:method:getRotationAngle"), [getScale]("GI.Clutter.Objects.Actor#g:method:getScale"), [getScaleCenter]("GI.Clutter.Objects.Actor#g:method:getScaleCenter"), [getScaleGravity]("GI.Clutter.Objects.Actor#g:method:getScaleGravity"), [getScaleZ]("GI.Clutter.Objects.Actor#g:method:getScaleZ"), [getSelectable]("GI.Clutter.Objects.Text#g:method:getSelectable"), [getSelectedTextColor]("GI.Clutter.Objects.Text#g:method:getSelectedTextColor"), [getSelection]("GI.Clutter.Objects.Text#g:method:getSelection"), [getSelectionBound]("GI.Clutter.Objects.Text#g:method:getSelectionBound"), [getSelectionColor]("GI.Clutter.Objects.Text#g:method:getSelectionColor"), [getShader]("GI.Clutter.Objects.Actor#g:method:getShader"), [getSingleLineMode]("GI.Clutter.Objects.Text#g:method:getSingleLineMode"), [getSize]("GI.Clutter.Objects.Actor#g:method:getSize"), [getStage]("GI.Clutter.Objects.Actor#g:method:getStage"), [getText]("GI.Clutter.Objects.Text#g:method:getText"), [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"), [getUseMarkup]("GI.Clutter.Objects.Text#g:method:getUseMarkup"), [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
-- [setActivatable]("GI.Clutter.Objects.Text#g:method:setActivatable"), [setAllocation]("GI.Clutter.Objects.Actor#g:method:setAllocation"), [setAnchorPoint]("GI.Clutter.Objects.Actor#g:method:setAnchorPoint"), [setAnchorPointFromGravity]("GI.Clutter.Objects.Actor#g:method:setAnchorPointFromGravity"), [setAttributes]("GI.Clutter.Objects.Text#g:method:setAttributes"), [setBackgroundColor]("GI.Clutter.Objects.Actor#g:method:setBackgroundColor"), [setBuffer]("GI.Clutter.Objects.Text#g:method:setBuffer"), [setChildAboveSibling]("GI.Clutter.Objects.Actor#g:method:setChildAboveSibling"), [setChildAtIndex]("GI.Clutter.Objects.Actor#g:method:setChildAtIndex"), [setChildBelowSibling]("GI.Clutter.Objects.Actor#g:method:setChildBelowSibling"), [setChildTransform]("GI.Clutter.Objects.Actor#g:method:setChildTransform"), [setClip]("GI.Clutter.Objects.Actor#g:method:setClip"), [setClipToAllocation]("GI.Clutter.Objects.Actor#g:method:setClipToAllocation"), [setColor]("GI.Clutter.Objects.Text#g:method:setColor"), [setContent]("GI.Clutter.Objects.Actor#g:method:setContent"), [setContentGravity]("GI.Clutter.Objects.Actor#g:method:setContentGravity"), [setContentRepeat]("GI.Clutter.Objects.Actor#g:method:setContentRepeat"), [setContentScalingFilters]("GI.Clutter.Objects.Actor#g:method:setContentScalingFilters"), [setCursorColor]("GI.Clutter.Objects.Text#g:method:setCursorColor"), [setCursorPosition]("GI.Clutter.Objects.Text#g:method:setCursorPosition"), [setCursorSize]("GI.Clutter.Objects.Text#g:method:setCursorSize"), [setCursorVisible]("GI.Clutter.Objects.Text#g:method:setCursorVisible"), [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"), [setEditable]("GI.Clutter.Objects.Text#g:method:setEditable"), [setEllipsize]("GI.Clutter.Objects.Text#g:method:setEllipsize"), [setFinalState]("GI.Clutter.Interfaces.Animatable#g:method:setFinalState"), [setFixedPositionSet]("GI.Clutter.Objects.Actor#g:method:setFixedPositionSet"), [setFlags]("GI.Clutter.Objects.Actor#g:method:setFlags"), [setFontDescription]("GI.Clutter.Objects.Text#g:method:setFontDescription"), [setFontName]("GI.Clutter.Objects.Text#g:method:setFontName"), [setGeometry]("GI.Clutter.Objects.Actor#g:method:setGeometry"), [setHeight]("GI.Clutter.Objects.Actor#g:method:setHeight"), [setId]("GI.Clutter.Interfaces.Scriptable#g:method:setId"), [setJustify]("GI.Clutter.Objects.Text#g:method:setJustify"), [setLayoutManager]("GI.Clutter.Objects.Actor#g:method:setLayoutManager"), [setLineAlignment]("GI.Clutter.Objects.Text#g:method:setLineAlignment"), [setLineWrap]("GI.Clutter.Objects.Text#g:method:setLineWrap"), [setLineWrapMode]("GI.Clutter.Objects.Text#g:method:setLineWrapMode"), [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"), [setMarkup]("GI.Clutter.Objects.Text#g:method:setMarkup"), [setMaxLength]("GI.Clutter.Objects.Text#g:method:setMaxLength"), [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"), [setPasswordChar]("GI.Clutter.Objects.Text#g:method:setPasswordChar"), [setPivotPoint]("GI.Clutter.Objects.Actor#g:method:setPivotPoint"), [setPivotPointZ]("GI.Clutter.Objects.Actor#g:method:setPivotPointZ"), [setPosition]("GI.Clutter.Objects.Actor#g:method:setPosition"), [setPreeditString]("GI.Clutter.Objects.Text#g:method:setPreeditString"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReactive]("GI.Clutter.Objects.Actor#g:method:setReactive"), [setRequestMode]("GI.Clutter.Objects.Actor#g:method:setRequestMode"), [setRotation]("GI.Clutter.Objects.Actor#g:method:setRotation"), [setRotationAngle]("GI.Clutter.Objects.Actor#g:method:setRotationAngle"), [setScale]("GI.Clutter.Objects.Actor#g:method:setScale"), [setScaleFull]("GI.Clutter.Objects.Actor#g:method:setScaleFull"), [setScaleWithGravity]("GI.Clutter.Objects.Actor#g:method:setScaleWithGravity"), [setScaleZ]("GI.Clutter.Objects.Actor#g:method:setScaleZ"), [setSelectable]("GI.Clutter.Objects.Text#g:method:setSelectable"), [setSelectedTextColor]("GI.Clutter.Objects.Text#g:method:setSelectedTextColor"), [setSelection]("GI.Clutter.Objects.Text#g:method:setSelection"), [setSelectionBound]("GI.Clutter.Objects.Text#g:method:setSelectionBound"), [setSelectionColor]("GI.Clutter.Objects.Text#g:method:setSelectionColor"), [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"), [setSingleLineMode]("GI.Clutter.Objects.Text#g:method:setSingleLineMode"), [setSize]("GI.Clutter.Objects.Actor#g:method:setSize"), [setText]("GI.Clutter.Objects.Text#g:method:setText"), [setTextDirection]("GI.Clutter.Objects.Actor#g:method:setTextDirection"), [setTransform]("GI.Clutter.Objects.Actor#g:method:setTransform"), [setTranslation]("GI.Clutter.Objects.Actor#g:method:setTranslation"), [setUseMarkup]("GI.Clutter.Objects.Text#g:method:setUseMarkup"), [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)
    ResolveTextMethod                       ,
#endif

-- ** activate #method:activate#

#if defined(ENABLE_OVERLOADING)
    TextActivateMethodInfo                  ,
#endif
    textActivate                            ,


-- ** coordsToPosition #method:coordsToPosition#

#if defined(ENABLE_OVERLOADING)
    TextCoordsToPositionMethodInfo          ,
#endif
    textCoordsToPosition                    ,


-- ** deleteChars #method:deleteChars#

#if defined(ENABLE_OVERLOADING)
    TextDeleteCharsMethodInfo               ,
#endif
    textDeleteChars                         ,


-- ** deleteSelection #method:deleteSelection#

#if defined(ENABLE_OVERLOADING)
    TextDeleteSelectionMethodInfo           ,
#endif
    textDeleteSelection                     ,


-- ** deleteText #method:deleteText#

#if defined(ENABLE_OVERLOADING)
    TextDeleteTextMethodInfo                ,
#endif
    textDeleteText                          ,


-- ** getActivatable #method:getActivatable#

#if defined(ENABLE_OVERLOADING)
    TextGetActivatableMethodInfo            ,
#endif
    textGetActivatable                      ,


-- ** getAttributes #method:getAttributes#

#if defined(ENABLE_OVERLOADING)
    TextGetAttributesMethodInfo             ,
#endif
    textGetAttributes                       ,


-- ** getBuffer #method:getBuffer#

#if defined(ENABLE_OVERLOADING)
    TextGetBufferMethodInfo                 ,
#endif
    textGetBuffer                           ,


-- ** getChars #method:getChars#

#if defined(ENABLE_OVERLOADING)
    TextGetCharsMethodInfo                  ,
#endif
    textGetChars                            ,


-- ** getColor #method:getColor#

#if defined(ENABLE_OVERLOADING)
    TextGetColorMethodInfo                  ,
#endif
    textGetColor                            ,


-- ** getCursorColor #method:getCursorColor#

#if defined(ENABLE_OVERLOADING)
    TextGetCursorColorMethodInfo            ,
#endif
    textGetCursorColor                      ,


-- ** getCursorPosition #method:getCursorPosition#

#if defined(ENABLE_OVERLOADING)
    TextGetCursorPositionMethodInfo         ,
#endif
    textGetCursorPosition                   ,


-- ** getCursorRect #method:getCursorRect#

#if defined(ENABLE_OVERLOADING)
    TextGetCursorRectMethodInfo             ,
#endif
    textGetCursorRect                       ,


-- ** getCursorSize #method:getCursorSize#

#if defined(ENABLE_OVERLOADING)
    TextGetCursorSizeMethodInfo             ,
#endif
    textGetCursorSize                       ,


-- ** getCursorVisible #method:getCursorVisible#

#if defined(ENABLE_OVERLOADING)
    TextGetCursorVisibleMethodInfo          ,
#endif
    textGetCursorVisible                    ,


-- ** getEditable #method:getEditable#

#if defined(ENABLE_OVERLOADING)
    TextGetEditableMethodInfo               ,
#endif
    textGetEditable                         ,


-- ** getEllipsize #method:getEllipsize#

#if defined(ENABLE_OVERLOADING)
    TextGetEllipsizeMethodInfo              ,
#endif
    textGetEllipsize                        ,


-- ** getFontDescription #method:getFontDescription#

#if defined(ENABLE_OVERLOADING)
    TextGetFontDescriptionMethodInfo        ,
#endif
    textGetFontDescription                  ,


-- ** getFontName #method:getFontName#

#if defined(ENABLE_OVERLOADING)
    TextGetFontNameMethodInfo               ,
#endif
    textGetFontName                         ,


-- ** getJustify #method:getJustify#

#if defined(ENABLE_OVERLOADING)
    TextGetJustifyMethodInfo                ,
#endif
    textGetJustify                          ,


-- ** getLayout #method:getLayout#

#if defined(ENABLE_OVERLOADING)
    TextGetLayoutMethodInfo                 ,
#endif
    textGetLayout                           ,


-- ** getLayoutOffsets #method:getLayoutOffsets#

#if defined(ENABLE_OVERLOADING)
    TextGetLayoutOffsetsMethodInfo          ,
#endif
    textGetLayoutOffsets                    ,


-- ** getLineAlignment #method:getLineAlignment#

#if defined(ENABLE_OVERLOADING)
    TextGetLineAlignmentMethodInfo          ,
#endif
    textGetLineAlignment                    ,


-- ** getLineWrap #method:getLineWrap#

#if defined(ENABLE_OVERLOADING)
    TextGetLineWrapMethodInfo               ,
#endif
    textGetLineWrap                         ,


-- ** getLineWrapMode #method:getLineWrapMode#

#if defined(ENABLE_OVERLOADING)
    TextGetLineWrapModeMethodInfo           ,
#endif
    textGetLineWrapMode                     ,


-- ** getMaxLength #method:getMaxLength#

#if defined(ENABLE_OVERLOADING)
    TextGetMaxLengthMethodInfo              ,
#endif
    textGetMaxLength                        ,


-- ** getPasswordChar #method:getPasswordChar#

#if defined(ENABLE_OVERLOADING)
    TextGetPasswordCharMethodInfo           ,
#endif
    textGetPasswordChar                     ,


-- ** getSelectable #method:getSelectable#

#if defined(ENABLE_OVERLOADING)
    TextGetSelectableMethodInfo             ,
#endif
    textGetSelectable                       ,


-- ** getSelectedTextColor #method:getSelectedTextColor#

#if defined(ENABLE_OVERLOADING)
    TextGetSelectedTextColorMethodInfo      ,
#endif
    textGetSelectedTextColor                ,


-- ** getSelection #method:getSelection#

#if defined(ENABLE_OVERLOADING)
    TextGetSelectionMethodInfo              ,
#endif
    textGetSelection                        ,


-- ** getSelectionBound #method:getSelectionBound#

#if defined(ENABLE_OVERLOADING)
    TextGetSelectionBoundMethodInfo         ,
#endif
    textGetSelectionBound                   ,


-- ** getSelectionColor #method:getSelectionColor#

#if defined(ENABLE_OVERLOADING)
    TextGetSelectionColorMethodInfo         ,
#endif
    textGetSelectionColor                   ,


-- ** getSingleLineMode #method:getSingleLineMode#

#if defined(ENABLE_OVERLOADING)
    TextGetSingleLineModeMethodInfo         ,
#endif
    textGetSingleLineMode                   ,


-- ** getText #method:getText#

#if defined(ENABLE_OVERLOADING)
    TextGetTextMethodInfo                   ,
#endif
    textGetText                             ,


-- ** getUseMarkup #method:getUseMarkup#

#if defined(ENABLE_OVERLOADING)
    TextGetUseMarkupMethodInfo              ,
#endif
    textGetUseMarkup                        ,


-- ** insertText #method:insertText#

#if defined(ENABLE_OVERLOADING)
    TextInsertTextMethodInfo                ,
#endif
    textInsertText                          ,


-- ** insertUnichar #method:insertUnichar#

#if defined(ENABLE_OVERLOADING)
    TextInsertUnicharMethodInfo             ,
#endif
    textInsertUnichar                       ,


-- ** new #method:new#

    textNew                                 ,


-- ** newFull #method:newFull#

    textNewFull                             ,


-- ** newWithBuffer #method:newWithBuffer#

    textNewWithBuffer                       ,


-- ** newWithText #method:newWithText#

    textNewWithText                         ,


-- ** positionToCoords #method:positionToCoords#

#if defined(ENABLE_OVERLOADING)
    TextPositionToCoordsMethodInfo          ,
#endif
    textPositionToCoords                    ,


-- ** setActivatable #method:setActivatable#

#if defined(ENABLE_OVERLOADING)
    TextSetActivatableMethodInfo            ,
#endif
    textSetActivatable                      ,


-- ** setAttributes #method:setAttributes#

#if defined(ENABLE_OVERLOADING)
    TextSetAttributesMethodInfo             ,
#endif
    textSetAttributes                       ,


-- ** setBuffer #method:setBuffer#

#if defined(ENABLE_OVERLOADING)
    TextSetBufferMethodInfo                 ,
#endif
    textSetBuffer                           ,


-- ** setColor #method:setColor#

#if defined(ENABLE_OVERLOADING)
    TextSetColorMethodInfo                  ,
#endif
    textSetColor                            ,


-- ** setCursorColor #method:setCursorColor#

#if defined(ENABLE_OVERLOADING)
    TextSetCursorColorMethodInfo            ,
#endif
    textSetCursorColor                      ,


-- ** setCursorPosition #method:setCursorPosition#

#if defined(ENABLE_OVERLOADING)
    TextSetCursorPositionMethodInfo         ,
#endif
    textSetCursorPosition                   ,


-- ** setCursorSize #method:setCursorSize#

#if defined(ENABLE_OVERLOADING)
    TextSetCursorSizeMethodInfo             ,
#endif
    textSetCursorSize                       ,


-- ** setCursorVisible #method:setCursorVisible#

#if defined(ENABLE_OVERLOADING)
    TextSetCursorVisibleMethodInfo          ,
#endif
    textSetCursorVisible                    ,


-- ** setEditable #method:setEditable#

#if defined(ENABLE_OVERLOADING)
    TextSetEditableMethodInfo               ,
#endif
    textSetEditable                         ,


-- ** setEllipsize #method:setEllipsize#

#if defined(ENABLE_OVERLOADING)
    TextSetEllipsizeMethodInfo              ,
#endif
    textSetEllipsize                        ,


-- ** setFontDescription #method:setFontDescription#

#if defined(ENABLE_OVERLOADING)
    TextSetFontDescriptionMethodInfo        ,
#endif
    textSetFontDescription                  ,


-- ** setFontName #method:setFontName#

#if defined(ENABLE_OVERLOADING)
    TextSetFontNameMethodInfo               ,
#endif
    textSetFontName                         ,


-- ** setJustify #method:setJustify#

#if defined(ENABLE_OVERLOADING)
    TextSetJustifyMethodInfo                ,
#endif
    textSetJustify                          ,


-- ** setLineAlignment #method:setLineAlignment#

#if defined(ENABLE_OVERLOADING)
    TextSetLineAlignmentMethodInfo          ,
#endif
    textSetLineAlignment                    ,


-- ** setLineWrap #method:setLineWrap#

#if defined(ENABLE_OVERLOADING)
    TextSetLineWrapMethodInfo               ,
#endif
    textSetLineWrap                         ,


-- ** setLineWrapMode #method:setLineWrapMode#

#if defined(ENABLE_OVERLOADING)
    TextSetLineWrapModeMethodInfo           ,
#endif
    textSetLineWrapMode                     ,


-- ** setMarkup #method:setMarkup#

#if defined(ENABLE_OVERLOADING)
    TextSetMarkupMethodInfo                 ,
#endif
    textSetMarkup                           ,


-- ** setMaxLength #method:setMaxLength#

#if defined(ENABLE_OVERLOADING)
    TextSetMaxLengthMethodInfo              ,
#endif
    textSetMaxLength                        ,


-- ** setPasswordChar #method:setPasswordChar#

#if defined(ENABLE_OVERLOADING)
    TextSetPasswordCharMethodInfo           ,
#endif
    textSetPasswordChar                     ,


-- ** setPreeditString #method:setPreeditString#

#if defined(ENABLE_OVERLOADING)
    TextSetPreeditStringMethodInfo          ,
#endif
    textSetPreeditString                    ,


-- ** setSelectable #method:setSelectable#

#if defined(ENABLE_OVERLOADING)
    TextSetSelectableMethodInfo             ,
#endif
    textSetSelectable                       ,


-- ** setSelectedTextColor #method:setSelectedTextColor#

#if defined(ENABLE_OVERLOADING)
    TextSetSelectedTextColorMethodInfo      ,
#endif
    textSetSelectedTextColor                ,


-- ** setSelection #method:setSelection#

#if defined(ENABLE_OVERLOADING)
    TextSetSelectionMethodInfo              ,
#endif
    textSetSelection                        ,


-- ** setSelectionBound #method:setSelectionBound#

#if defined(ENABLE_OVERLOADING)
    TextSetSelectionBoundMethodInfo         ,
#endif
    textSetSelectionBound                   ,


-- ** setSelectionColor #method:setSelectionColor#

#if defined(ENABLE_OVERLOADING)
    TextSetSelectionColorMethodInfo         ,
#endif
    textSetSelectionColor                   ,


-- ** setSingleLineMode #method:setSingleLineMode#

#if defined(ENABLE_OVERLOADING)
    TextSetSingleLineModeMethodInfo         ,
#endif
    textSetSingleLineMode                   ,


-- ** setText #method:setText#

#if defined(ENABLE_OVERLOADING)
    TextSetTextMethodInfo                   ,
#endif
    textSetText                             ,


-- ** setUseMarkup #method:setUseMarkup#

#if defined(ENABLE_OVERLOADING)
    TextSetUseMarkupMethodInfo              ,
#endif
    textSetUseMarkup                        ,




 -- * Properties


-- ** activatable #attr:activatable#
-- | Toggles whether return invokes the activate signal or not.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextActivatablePropertyInfo             ,
#endif
    constructTextActivatable                ,
    getTextActivatable                      ,
    setTextActivatable                      ,
#if defined(ENABLE_OVERLOADING)
    textActivatable                         ,
#endif


-- ** attributes #attr:attributes#
-- | A list of @/PangoStyleAttribute/@s to be applied to the
-- contents of the t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextAttributesPropertyInfo              ,
#endif
    clearTextAttributes                     ,
    constructTextAttributes                 ,
    getTextAttributes                       ,
    setTextAttributes                       ,
#if defined(ENABLE_OVERLOADING)
    textAttributes                          ,
#endif


-- ** buffer #attr:buffer#
-- | The buffer which stores the text for this t'GI.Clutter.Objects.Text.Text'.
-- 
-- If set to 'P.Nothing', a default buffer will be created.
-- 
-- /Since: 1.8/

#if defined(ENABLE_OVERLOADING)
    TextBufferPropertyInfo                  ,
#endif
    constructTextBuffer                     ,
    getTextBuffer                           ,
    setTextBuffer                           ,
#if defined(ENABLE_OVERLOADING)
    textBuffer                              ,
#endif


-- ** color #attr:color#
-- | The color used to render the text.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextColorPropertyInfo                   ,
#endif
    constructTextColor                      ,
    getTextColor                            ,
    setTextColor                            ,
#if defined(ENABLE_OVERLOADING)
    textColor                               ,
#endif


-- ** cursorColor #attr:cursorColor#
-- | The color of the cursor.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextCursorColorPropertyInfo             ,
#endif
    clearTextCursorColor                    ,
    constructTextCursorColor                ,
    getTextCursorColor                      ,
    setTextCursorColor                      ,
#if defined(ENABLE_OVERLOADING)
    textCursorColor                         ,
#endif


-- ** cursorColorSet #attr:cursorColorSet#
-- | Will be set to 'P.True' if t'GI.Clutter.Objects.Text.Text':@/cursor-color/@ has been set.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextCursorColorSetPropertyInfo          ,
#endif
    getTextCursorColorSet                   ,
#if defined(ENABLE_OVERLOADING)
    textCursorColorSet                      ,
#endif


-- ** cursorPosition #attr:cursorPosition#
-- | The current input cursor position. -1 is taken to be the end of the text
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    TextCursorPositionPropertyInfo          ,
#endif
    constructTextCursorPosition             ,
    getTextCursorPosition                   ,
    setTextCursorPosition                   ,
#if defined(ENABLE_OVERLOADING)
    textCursorPosition                      ,
#endif


-- ** cursorSize #attr:cursorSize#
-- | The size of the cursor, in pixels. If set to -1 the size used will
-- be the default cursor size of 2 pixels.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextCursorSizePropertyInfo              ,
#endif
    constructTextCursorSize                 ,
    getTextCursorSize                       ,
    setTextCursorSize                       ,
#if defined(ENABLE_OVERLOADING)
    textCursorSize                          ,
#endif


-- ** cursorVisible #attr:cursorVisible#
-- | Whether the input cursor is visible or not.
-- 
-- The cursor will only be visible if this property and either
-- the t'GI.Clutter.Objects.Text.Text':@/editable/@ or the t'GI.Clutter.Objects.Text.Text':@/selectable/@ properties
-- are set to 'P.True'.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextCursorVisiblePropertyInfo           ,
#endif
    constructTextCursorVisible              ,
    getTextCursorVisible                    ,
    setTextCursorVisible                    ,
#if defined(ENABLE_OVERLOADING)
    textCursorVisible                       ,
#endif


-- ** editable #attr:editable#
-- | Whether key events delivered to the actor causes editing.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextEditablePropertyInfo                ,
#endif
    constructTextEditable                   ,
    getTextEditable                         ,
    setTextEditable                         ,
#if defined(ENABLE_OVERLOADING)
    textEditable                            ,
#endif


-- ** ellipsize #attr:ellipsize#
-- | The preferred place to ellipsize the contents of the t'GI.Clutter.Objects.Text.Text' actor
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextEllipsizePropertyInfo               ,
#endif
    constructTextEllipsize                  ,
    getTextEllipsize                        ,
    setTextEllipsize                        ,
#if defined(ENABLE_OVERLOADING)
    textEllipsize                           ,
#endif


-- ** fontDescription #attr:fontDescription#
-- | The t'GI.Pango.Structs.FontDescription.FontDescription' that should be used by the t'GI.Clutter.Objects.Text.Text'
-- 
-- If you have a string describing the font then you should look at
-- t'GI.Clutter.Objects.Text.Text':@/font-name/@ instead
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    TextFontDescriptionPropertyInfo         ,
#endif
    constructTextFontDescription            ,
    getTextFontDescription                  ,
    setTextFontDescription                  ,
#if defined(ENABLE_OVERLOADING)
    textFontDescription                     ,
#endif


-- ** fontName #attr:fontName#
-- | The font to be used by the t'GI.Clutter.Objects.Text.Text', as a string
-- that can be parsed by 'GI.Pango.Functions.fontDescriptionFromString'.
-- 
-- If set to 'P.Nothing', the default system font will be used instead.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextFontNamePropertyInfo                ,
#endif
    clearTextFontName                       ,
    constructTextFontName                   ,
    getTextFontName                         ,
    setTextFontName                         ,
#if defined(ENABLE_OVERLOADING)
    textFontName                            ,
#endif


-- ** justify #attr:justify#
-- | Whether the contents of the t'GI.Clutter.Objects.Text.Text' should be justified
-- on both margins.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextJustifyPropertyInfo                 ,
#endif
    constructTextJustify                    ,
    getTextJustify                          ,
    setTextJustify                          ,
#if defined(ENABLE_OVERLOADING)
    textJustify                             ,
#endif


-- ** lineAlignment #attr:lineAlignment#
-- | The preferred alignment for the text. This property controls
-- the alignment of multi-line paragraphs.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextLineAlignmentPropertyInfo           ,
#endif
    constructTextLineAlignment              ,
    getTextLineAlignment                    ,
    setTextLineAlignment                    ,
#if defined(ENABLE_OVERLOADING)
    textLineAlignment                       ,
#endif


-- ** lineWrap #attr:lineWrap#
-- | Whether to wrap the lines of t'GI.Clutter.Objects.Text.Text':@/text/@ if the contents
-- exceed the available allocation. The wrapping strategy is
-- controlled by the t'GI.Clutter.Objects.Text.Text':@/line-wrap-mode/@ property.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextLineWrapPropertyInfo                ,
#endif
    constructTextLineWrap                   ,
    getTextLineWrap                         ,
    setTextLineWrap                         ,
#if defined(ENABLE_OVERLOADING)
    textLineWrap                            ,
#endif


-- ** lineWrapMode #attr:lineWrapMode#
-- | If t'GI.Clutter.Objects.Text.Text':@/line-wrap/@ is set to 'P.True', this property will
-- control how the text is wrapped.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextLineWrapModePropertyInfo            ,
#endif
    constructTextLineWrapMode               ,
    getTextLineWrapMode                     ,
    setTextLineWrapMode                     ,
#if defined(ENABLE_OVERLOADING)
    textLineWrapMode                        ,
#endif


-- ** maxLength #attr:maxLength#
-- | The maximum length of the contents of the t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextMaxLengthPropertyInfo               ,
#endif
    constructTextMaxLength                  ,
    getTextMaxLength                        ,
    setTextMaxLength                        ,
#if defined(ENABLE_OVERLOADING)
    textMaxLength                           ,
#endif


-- ** passwordChar #attr:passwordChar#
-- | If non-zero, the character that should be used in place of
-- the actual text in a password text actor.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextPasswordCharPropertyInfo            ,
#endif
    constructTextPasswordChar               ,
    getTextPasswordChar                     ,
    setTextPasswordChar                     ,
#if defined(ENABLE_OVERLOADING)
    textPasswordChar                        ,
#endif


-- ** position #attr:position#
-- | The current input cursor position. -1 is taken to be the end of the text
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextPositionPropertyInfo                ,
#endif
    constructTextPosition                   ,
    getTextPosition                         ,
    setTextPosition                         ,
#if defined(ENABLE_OVERLOADING)
    textPosition                            ,
#endif


-- ** selectable #attr:selectable#
-- | Whether it is possible to select text, either using the pointer
-- or the keyboard.
-- 
-- This property depends on the t'GI.Clutter.Objects.Actor.Actor':@/reactive/@ property being
-- set to 'P.True'.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextSelectablePropertyInfo              ,
#endif
    constructTextSelectable                 ,
    getTextSelectable                       ,
    setTextSelectable                       ,
#if defined(ENABLE_OVERLOADING)
    textSelectable                          ,
#endif


-- ** selectedTextColor #attr:selectedTextColor#
-- | The color of selected text.
-- 
-- /Since: 1.8/

#if defined(ENABLE_OVERLOADING)
    TextSelectedTextColorPropertyInfo       ,
#endif
    clearTextSelectedTextColor              ,
    constructTextSelectedTextColor          ,
    getTextSelectedTextColor                ,
    setTextSelectedTextColor                ,
#if defined(ENABLE_OVERLOADING)
    textSelectedTextColor                   ,
#endif


-- ** selectedTextColorSet #attr:selectedTextColorSet#
-- | Will be set to 'P.True' if t'GI.Clutter.Objects.Text.Text':@/selected-text-color/@ has been set.
-- 
-- /Since: 1.8/

#if defined(ENABLE_OVERLOADING)
    TextSelectedTextColorSetPropertyInfo    ,
#endif
    getTextSelectedTextColorSet             ,
#if defined(ENABLE_OVERLOADING)
    textSelectedTextColorSet                ,
#endif


-- ** selectionBound #attr:selectionBound#
-- | The current input cursor position. -1 is taken to be the end of the text
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextSelectionBoundPropertyInfo          ,
#endif
    constructTextSelectionBound             ,
    getTextSelectionBound                   ,
    setTextSelectionBound                   ,
#if defined(ENABLE_OVERLOADING)
    textSelectionBound                      ,
#endif


-- ** selectionColor #attr:selectionColor#
-- | The color of the selection.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextSelectionColorPropertyInfo          ,
#endif
    clearTextSelectionColor                 ,
    constructTextSelectionColor             ,
    getTextSelectionColor                   ,
    setTextSelectionColor                   ,
#if defined(ENABLE_OVERLOADING)
    textSelectionColor                      ,
#endif


-- ** selectionColorSet #attr:selectionColorSet#
-- | Will be set to 'P.True' if t'GI.Clutter.Objects.Text.Text':@/selection-color/@ has been set.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextSelectionColorSetPropertyInfo       ,
#endif
    getTextSelectionColorSet                ,
#if defined(ENABLE_OVERLOADING)
    textSelectionColorSet                   ,
#endif


-- ** singleLineMode #attr:singleLineMode#
-- | Whether the t'GI.Clutter.Objects.Text.Text' actor should be in single line mode
-- or not. A single line t'GI.Clutter.Objects.Text.Text' actor will only contain a
-- single line of text, scrolling it in case its length is bigger
-- than the allocated size.
-- 
-- Setting this property will also set the t'GI.Clutter.Objects.Text.Text':@/activatable/@
-- property as a side-effect.
-- 
-- The t'GI.Clutter.Objects.Text.Text':@/single-line-mode/@ property is used only if the
-- t'GI.Clutter.Objects.Text.Text':@/editable/@ property is set to 'P.True'.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextSingleLineModePropertyInfo          ,
#endif
    constructTextSingleLineMode             ,
    getTextSingleLineMode                   ,
    setTextSingleLineMode                   ,
#if defined(ENABLE_OVERLOADING)
    textSingleLineMode                      ,
#endif


-- ** text #attr:text#
-- | The text to render inside the actor.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextTextPropertyInfo                    ,
#endif
    clearTextText                           ,
    constructTextText                       ,
    getTextText                             ,
    setTextText                             ,
#if defined(ENABLE_OVERLOADING)
    textText                                ,
#endif


-- ** useMarkup #attr:useMarkup#
-- | Whether the text includes Pango markup.
-- 
-- For more informations about the Pango markup format, see
-- 'GI.Pango.Objects.Layout.layoutSetMarkup' in the Pango documentation.
-- 
-- It is not possible to round-trip this property between
-- 'P.True' and 'P.False'. Once a string with markup has been set on
-- a t'GI.Clutter.Objects.Text.Text' actor with :use-markup set to 'P.True', the markup
-- is stripped from the string.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TextUseMarkupPropertyInfo               ,
#endif
    constructTextUseMarkup                  ,
    getTextUseMarkup                        ,
    setTextUseMarkup                        ,
#if defined(ENABLE_OVERLOADING)
    textUseMarkup                           ,
#endif




 -- * Signals


-- ** activate #signal:activate#

    TextActivateCallback                    ,
#if defined(ENABLE_OVERLOADING)
    TextActivateSignalInfo                  ,
#endif
    afterTextActivate                       ,
    onTextActivate                          ,


-- ** cursorChanged #signal:cursorChanged#

    TextCursorChangedCallback               ,
#if defined(ENABLE_OVERLOADING)
    TextCursorChangedSignalInfo             ,
#endif
    afterTextCursorChanged                  ,
    onTextCursorChanged                     ,


-- ** cursorEvent #signal:cursorEvent#

    TextCursorEventCallback                 ,
#if defined(ENABLE_OVERLOADING)
    TextCursorEventSignalInfo               ,
#endif
    afterTextCursorEvent                    ,
    onTextCursorEvent                       ,


-- ** deleteText #signal:deleteText#

    TextDeleteTextCallback                  ,
#if defined(ENABLE_OVERLOADING)
    TextDeleteTextSignalInfo                ,
#endif
    afterTextDeleteText                     ,
    onTextDeleteText                        ,


-- ** insertText #signal:insertText#

    TextInsertTextCallback                  ,
#if defined(ENABLE_OVERLOADING)
    TextInsertTextSignalInfo                ,
#endif
    afterTextInsertText                     ,
    onTextInsertText                        ,


-- ** textChanged #signal:textChanged#

    TextTextChangedCallback                 ,
#if defined(ENABLE_OVERLOADING)
    TextTextChangedSignalInfo               ,
#endif
    afterTextTextChanged                    ,
    onTextTextChanged                       ,




    ) where

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

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

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Animatable as Clutter.Animatable
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Container as Clutter.Container
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.TextBuffer as Clutter.TextBuffer
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import {-# SOURCE #-} qualified GI.Clutter.Structs.Geometry as Clutter.Geometry
import {-# SOURCE #-} qualified GI.Clutter.Structs.Rect as Clutter.Rect
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Pango.Enums as Pango.Enums
import qualified GI.Pango.Objects.Layout as Pango.Layout
import qualified GI.Pango.Structs.AttrList as Pango.AttrList
import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription

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

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

foreign import ccall "clutter_text_get_type"
    c_clutter_text_get_type :: IO B.Types.GType

instance B.Types.TypedObject Text where
    glibType :: IO GType
glibType = IO GType
c_clutter_text_get_type

instance B.Types.GObject Text

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

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

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

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

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

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

#endif

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

#endif

-- signal Text::activate
-- | The [activate](#g:signal:activate) signal is emitted each time the actor is \'activated\'
-- by the user, normally by pressing the \'Enter\' key. The signal is
-- emitted only if t'GI.Clutter.Objects.Text.Text':@/activatable/@ is set to 'P.True'.
-- 
-- /Since: 1.0/
type TextActivateCallback =
    IO ()

type C_TextActivateCallback =
    Ptr Text ->                             -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TextActivateCallback :: 
    GObject a => (a -> TextActivateCallback) ->
    C_TextActivateCallback
wrap_TextActivateCallback :: forall a. GObject a => (a -> IO ()) -> C_TextActivateCallback
wrap_TextActivateCallback a -> IO ()
gi'cb Ptr Text
gi'selfPtr Ptr ()
_ = do
    Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> IO ()
gi'cb (Text -> a
Coerce.coerce Text
gi'self) 


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

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


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

#endif

-- signal Text::cursor-changed
-- | The [cursorChanged](#g:signal:cursorChanged) signal is emitted whenever the cursor
-- position or size changes.
-- 
-- /Since: 1.16/
type TextCursorChangedCallback =
    IO ()

type C_TextCursorChangedCallback =
    Ptr Text ->                             -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TextCursorChangedCallback :: 
    GObject a => (a -> TextCursorChangedCallback) ->
    C_TextCursorChangedCallback
wrap_TextCursorChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TextActivateCallback
wrap_TextCursorChangedCallback a -> IO ()
gi'cb Ptr Text
gi'selfPtr Ptr ()
_ = do
    Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> IO ()
gi'cb (Text -> a
Coerce.coerce Text
gi'self) 


-- | Connect a signal handler for the [cursorChanged](#signal:cursorChanged) 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' text #cursorChanged callback
-- @
-- 
-- 
onTextCursorChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextCursorChangedCallback) -> m SignalHandlerId
onTextCursorChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTextCursorChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TextActivateCallback
wrapped' = (a -> IO ()) -> C_TextActivateCallback
forall a. GObject a => (a -> IO ()) -> C_TextActivateCallback
wrap_TextCursorChangedCallback a -> IO ()
wrapped
    FunPtr C_TextActivateCallback
wrapped'' <- C_TextActivateCallback -> IO (FunPtr C_TextActivateCallback)
mk_TextCursorChangedCallback C_TextActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_TextActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-changed" FunPtr C_TextActivateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cursorChanged](#signal:cursorChanged) 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' text #cursorChanged 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.
-- 
afterTextCursorChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextCursorChangedCallback) -> m SignalHandlerId
afterTextCursorChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTextCursorChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TextActivateCallback
wrapped' = (a -> IO ()) -> C_TextActivateCallback
forall a. GObject a => (a -> IO ()) -> C_TextActivateCallback
wrap_TextCursorChangedCallback a -> IO ()
wrapped
    FunPtr C_TextActivateCallback
wrapped'' <- C_TextActivateCallback -> IO (FunPtr C_TextActivateCallback)
mk_TextCursorChangedCallback C_TextActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_TextActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-changed" FunPtr C_TextActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextCursorChangedSignalInfo
instance SignalInfo TextCursorChangedSignalInfo where
    type HaskellCallbackType TextCursorChangedSignalInfo = TextCursorChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextCursorChangedCallback cb
        cb'' <- mk_TextCursorChangedCallback cb'
        connectSignalFunPtr obj "cursor-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text::cursor-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:signal:cursorChanged"})

#endif

-- signal Text::cursor-event
{-# DEPRECATED TextCursorEventCallback ["(Since version 1.16)","Use the [cursorChanged](\"GI.Clutter.Objects.Text#g:signal:cursorChanged\") signal instead"] #-}
-- | The [cursorEvent](#g:signal:cursorEvent) signal is emitted whenever the cursor position
-- changes inside a t'GI.Clutter.Objects.Text.Text' actor. Inside /@geometry@/ it is stored
-- the current position and size of the cursor, relative to the actor
-- itself.
-- 
-- /Since: 1.0/
type TextCursorEventCallback =
    Clutter.Geometry.Geometry
    -- ^ /@geometry@/: the coordinates of the cursor
    -> IO ()

type C_TextCursorEventCallback =
    Ptr Text ->                             -- object
    Ptr Clutter.Geometry.Geometry ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TextCursorEventCallback :: 
    GObject a => (a -> TextCursorEventCallback) ->
    C_TextCursorEventCallback
wrap_TextCursorEventCallback :: forall a.
GObject a =>
(a -> TextCursorEventCallback) -> C_TextCursorEventCallback
wrap_TextCursorEventCallback a -> TextCursorEventCallback
gi'cb Ptr Text
gi'selfPtr Ptr Geometry
geometry Ptr ()
_ = do
    Ptr Geometry -> TextCursorEventCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Geometry
geometry (TextCursorEventCallback -> IO ())
-> TextCursorEventCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \Geometry
geometry' -> do
        Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> TextCursorEventCallback
gi'cb (Text -> a
Coerce.coerce Text
gi'self)  Geometry
geometry'


-- | Connect a signal handler for the [cursorEvent](#signal:cursorEvent) 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' text #cursorEvent callback
-- @
-- 
-- 
onTextCursorEvent :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextCursorEventCallback) -> m SignalHandlerId
onTextCursorEvent :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => TextCursorEventCallback) -> m SignalHandlerId
onTextCursorEvent a
obj (?self::a) => TextCursorEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextCursorEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextCursorEventCallback
TextCursorEventCallback
cb
    let wrapped' :: C_TextCursorEventCallback
wrapped' = (a -> TextCursorEventCallback) -> C_TextCursorEventCallback
forall a.
GObject a =>
(a -> TextCursorEventCallback) -> C_TextCursorEventCallback
wrap_TextCursorEventCallback a -> TextCursorEventCallback
wrapped
    FunPtr C_TextCursorEventCallback
wrapped'' <- C_TextCursorEventCallback -> IO (FunPtr C_TextCursorEventCallback)
mk_TextCursorEventCallback C_TextCursorEventCallback
wrapped'
    a
-> Text
-> FunPtr C_TextCursorEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-event" FunPtr C_TextCursorEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cursorEvent](#signal:cursorEvent) 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' text #cursorEvent 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.
-- 
afterTextCursorEvent :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextCursorEventCallback) -> m SignalHandlerId
afterTextCursorEvent :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => TextCursorEventCallback) -> m SignalHandlerId
afterTextCursorEvent a
obj (?self::a) => TextCursorEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextCursorEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextCursorEventCallback
TextCursorEventCallback
cb
    let wrapped' :: C_TextCursorEventCallback
wrapped' = (a -> TextCursorEventCallback) -> C_TextCursorEventCallback
forall a.
GObject a =>
(a -> TextCursorEventCallback) -> C_TextCursorEventCallback
wrap_TextCursorEventCallback a -> TextCursorEventCallback
wrapped
    FunPtr C_TextCursorEventCallback
wrapped'' <- C_TextCursorEventCallback -> IO (FunPtr C_TextCursorEventCallback)
mk_TextCursorEventCallback C_TextCursorEventCallback
wrapped'
    a
-> Text
-> FunPtr C_TextCursorEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-event" FunPtr C_TextCursorEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextCursorEventSignalInfo
instance SignalInfo TextCursorEventSignalInfo where
    type HaskellCallbackType TextCursorEventSignalInfo = TextCursorEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextCursorEventCallback cb
        cb'' <- mk_TextCursorEventCallback cb'
        connectSignalFunPtr obj "cursor-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text::cursor-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:signal:cursorEvent"})

#endif

-- signal Text::delete-text
-- | This signal is emitted when text is deleted from the actor by
-- the user. It is emitted before /@self@/ text changes.
-- 
-- /Since: 1.2/
type TextDeleteTextCallback =
    Int32
    -- ^ /@startPos@/: the starting position
    -> Int32
    -- ^ /@endPos@/: the end position
    -> IO ()

type C_TextDeleteTextCallback =
    Ptr Text ->                             -- object
    Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TextDeleteTextCallback :: 
    GObject a => (a -> TextDeleteTextCallback) ->
    C_TextDeleteTextCallback
wrap_TextDeleteTextCallback :: forall a.
GObject a =>
(a -> TextDeleteTextCallback) -> C_TextDeleteTextCallback
wrap_TextDeleteTextCallback a -> TextDeleteTextCallback
gi'cb Ptr Text
gi'selfPtr Int32
startPos Int32
endPos Ptr ()
_ = do
    Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> TextDeleteTextCallback
gi'cb (Text -> a
Coerce.coerce Text
gi'self)  Int32
startPos Int32
endPos


-- | Connect a signal handler for the [deleteText](#signal:deleteText) 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' text #deleteText callback
-- @
-- 
-- 
onTextDeleteText :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextDeleteTextCallback) -> m SignalHandlerId
onTextDeleteText :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => TextDeleteTextCallback) -> m SignalHandlerId
onTextDeleteText a
obj (?self::a) => TextDeleteTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextDeleteTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextDeleteTextCallback
TextDeleteTextCallback
cb
    let wrapped' :: C_TextDeleteTextCallback
wrapped' = (a -> TextDeleteTextCallback) -> C_TextDeleteTextCallback
forall a.
GObject a =>
(a -> TextDeleteTextCallback) -> C_TextDeleteTextCallback
wrap_TextDeleteTextCallback a -> TextDeleteTextCallback
wrapped
    FunPtr C_TextDeleteTextCallback
wrapped'' <- C_TextDeleteTextCallback -> IO (FunPtr C_TextDeleteTextCallback)
mk_TextDeleteTextCallback C_TextDeleteTextCallback
wrapped'
    a
-> Text
-> FunPtr C_TextDeleteTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"delete-text" FunPtr C_TextDeleteTextCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [deleteText](#signal:deleteText) 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' text #deleteText 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.
-- 
afterTextDeleteText :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextDeleteTextCallback) -> m SignalHandlerId
afterTextDeleteText :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => TextDeleteTextCallback) -> m SignalHandlerId
afterTextDeleteText a
obj (?self::a) => TextDeleteTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextDeleteTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextDeleteTextCallback
TextDeleteTextCallback
cb
    let wrapped' :: C_TextDeleteTextCallback
wrapped' = (a -> TextDeleteTextCallback) -> C_TextDeleteTextCallback
forall a.
GObject a =>
(a -> TextDeleteTextCallback) -> C_TextDeleteTextCallback
wrap_TextDeleteTextCallback a -> TextDeleteTextCallback
wrapped
    FunPtr C_TextDeleteTextCallback
wrapped'' <- C_TextDeleteTextCallback -> IO (FunPtr C_TextDeleteTextCallback)
mk_TextDeleteTextCallback C_TextDeleteTextCallback
wrapped'
    a
-> Text
-> FunPtr C_TextDeleteTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"delete-text" FunPtr C_TextDeleteTextCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextDeleteTextSignalInfo
instance SignalInfo TextDeleteTextSignalInfo where
    type HaskellCallbackType TextDeleteTextSignalInfo = TextDeleteTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextDeleteTextCallback cb
        cb'' <- mk_TextDeleteTextCallback cb'
        connectSignalFunPtr obj "delete-text" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text::delete-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:signal:deleteText"})

#endif

-- signal Text::insert-text
-- | This signal is emitted when text is inserted into the actor by
-- the user. It is emitted before /@self@/ text changes.
-- 
-- /Since: 1.2/
type TextInsertTextCallback =
    T.Text
    -- ^ /@newText@/: the new text to insert
    -> Int32
    -- ^ /@newTextLength@/: the length of the new text, in bytes, or -1 if
    --     new_text is nul-terminated
    -> Ptr ()
    -- ^ /@position@/: the position, in characters, at which to insert the
    --     new text. this is an in-out parameter.  After the signal
    --     emission is finished, it should point after the newly
    --     inserted text.
    -> IO ()

type C_TextInsertTextCallback =
    Ptr Text ->                             -- object
    CString ->
    Int32 ->
    Ptr () ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TextInsertTextCallback :: 
    GObject a => (a -> TextInsertTextCallback) ->
    C_TextInsertTextCallback
wrap_TextInsertTextCallback :: forall a.
GObject a =>
(a -> TextInsertTextCallback) -> C_TextInsertTextCallback
wrap_TextInsertTextCallback a -> TextInsertTextCallback
gi'cb Ptr Text
gi'selfPtr CString
newText Int32
newTextLength Ptr ()
position Ptr ()
_ = do
    Text
newText' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
newText
    Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> TextInsertTextCallback
gi'cb (Text -> a
Coerce.coerce Text
gi'self)  Text
newText' Int32
newTextLength Ptr ()
position


-- | Connect a signal handler for the [insertText](#signal:insertText) 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' text #insertText callback
-- @
-- 
-- 
onTextInsertText :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextInsertTextCallback) -> m SignalHandlerId
onTextInsertText :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => TextInsertTextCallback) -> m SignalHandlerId
onTextInsertText a
obj (?self::a) => TextInsertTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextInsertTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextInsertTextCallback
TextInsertTextCallback
cb
    let wrapped' :: C_TextInsertTextCallback
wrapped' = (a -> TextInsertTextCallback) -> C_TextInsertTextCallback
forall a.
GObject a =>
(a -> TextInsertTextCallback) -> C_TextInsertTextCallback
wrap_TextInsertTextCallback a -> TextInsertTextCallback
wrapped
    FunPtr C_TextInsertTextCallback
wrapped'' <- C_TextInsertTextCallback -> IO (FunPtr C_TextInsertTextCallback)
mk_TextInsertTextCallback C_TextInsertTextCallback
wrapped'
    a
-> Text
-> FunPtr C_TextInsertTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"insert-text" FunPtr C_TextInsertTextCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [insertText](#signal:insertText) 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' text #insertText 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.
-- 
afterTextInsertText :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextInsertTextCallback) -> m SignalHandlerId
afterTextInsertText :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => TextInsertTextCallback) -> m SignalHandlerId
afterTextInsertText a
obj (?self::a) => TextInsertTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TextInsertTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TextInsertTextCallback
TextInsertTextCallback
cb
    let wrapped' :: C_TextInsertTextCallback
wrapped' = (a -> TextInsertTextCallback) -> C_TextInsertTextCallback
forall a.
GObject a =>
(a -> TextInsertTextCallback) -> C_TextInsertTextCallback
wrap_TextInsertTextCallback a -> TextInsertTextCallback
wrapped
    FunPtr C_TextInsertTextCallback
wrapped'' <- C_TextInsertTextCallback -> IO (FunPtr C_TextInsertTextCallback)
mk_TextInsertTextCallback C_TextInsertTextCallback
wrapped'
    a
-> Text
-> FunPtr C_TextInsertTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"insert-text" FunPtr C_TextInsertTextCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextInsertTextSignalInfo
instance SignalInfo TextInsertTextSignalInfo where
    type HaskellCallbackType TextInsertTextSignalInfo = TextInsertTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextInsertTextCallback cb
        cb'' <- mk_TextInsertTextCallback cb'
        connectSignalFunPtr obj "insert-text" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text::insert-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:signal:insertText"})

#endif

-- signal Text::text-changed
-- | The [textChanged](#g:signal:textChanged) signal is emitted after /@actor@/\'s text changes
-- 
-- /Since: 1.0/
type TextTextChangedCallback =
    IO ()

type C_TextTextChangedCallback =
    Ptr Text ->                             -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TextTextChangedCallback :: 
    GObject a => (a -> TextTextChangedCallback) ->
    C_TextTextChangedCallback
wrap_TextTextChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_TextActivateCallback
wrap_TextTextChangedCallback a -> IO ()
gi'cb Ptr Text
gi'selfPtr Ptr ()
_ = do
    Ptr Text -> (Text -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Text
gi'selfPtr ((Text -> IO ()) -> IO ()) -> (Text -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Text
gi'self -> a -> IO ()
gi'cb (Text -> a
Coerce.coerce Text
gi'self) 


-- | Connect a signal handler for the [textChanged](#signal:textChanged) 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' text #textChanged callback
-- @
-- 
-- 
onTextTextChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextTextChangedCallback) -> m SignalHandlerId
onTextTextChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTextTextChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TextActivateCallback
wrapped' = (a -> IO ()) -> C_TextActivateCallback
forall a. GObject a => (a -> IO ()) -> C_TextActivateCallback
wrap_TextTextChangedCallback a -> IO ()
wrapped
    FunPtr C_TextActivateCallback
wrapped'' <- C_TextActivateCallback -> IO (FunPtr C_TextActivateCallback)
mk_TextTextChangedCallback C_TextActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_TextActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-changed" FunPtr C_TextActivateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [textChanged](#signal:textChanged) 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' text #textChanged 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.
-- 
afterTextTextChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextTextChangedCallback) -> m SignalHandlerId
afterTextTextChanged :: forall a (m :: * -> *).
(IsText a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTextTextChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_TextActivateCallback
wrapped' = (a -> IO ()) -> C_TextActivateCallback
forall a. GObject a => (a -> IO ()) -> C_TextActivateCallback
wrap_TextTextChangedCallback a -> IO ()
wrapped
    FunPtr C_TextActivateCallback
wrapped'' <- C_TextActivateCallback -> IO (FunPtr C_TextActivateCallback)
mk_TextTextChangedCallback C_TextActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_TextActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"text-changed" FunPtr C_TextActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TextTextChangedSignalInfo
instance SignalInfo TextTextChangedSignalInfo where
    type HaskellCallbackType TextTextChangedSignalInfo = TextTextChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TextTextChangedCallback cb
        cb'' <- mk_TextTextChangedCallback cb'
        connectSignalFunPtr obj "text-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text::text-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:signal:textChanged"})

#endif

--- XXX Duplicated object with different types:
  --- Name {namespace = "Clutter", name = "Text"} -> Property {propName = "position", propType = TBasicType TInt, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The current input cursor position. -1 is taken to be the end of the text", sinceVersion = Just "1.0"}, propDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "1.12", deprecationMessage = Just "Use ClutterText:cursor-position instead."})}
  --- Name {namespace = "Clutter", name = "Actor"} -> Property {propName = "position", propType = TInterface (Name {namespace = "Clutter", name = "Point"}), propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The position of the origin of the actor.\n\nThis property is a shorthand for setting and getting the\n#ClutterActor:x and #ClutterActor:y properties at the same\ntime.\n\nThe #ClutterActor:position property is animatable.", sinceVersion = Just "1.12"}, propDeprecated = Nothing}
-- VVV Prop "activatable"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

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

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

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

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

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

-- | Set the value of the “@attributes@” 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' #attributes
-- @
clearTextAttributes :: (MonadIO m, IsText o) => o -> m ()
clearTextAttributes :: forall (m :: * -> *) o. (MonadIO m, IsText o) => o -> m ()
clearTextAttributes o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe AttrList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"attributes" (Maybe AttrList
forall a. Maybe a
Nothing :: Maybe Pango.AttrList.AttrList)

#if defined(ENABLE_OVERLOADING)
data TextAttributesPropertyInfo
instance AttrInfo TextAttributesPropertyInfo where
    type AttrAllowedOps TextAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TextAttributesPropertyInfo = IsText
    type AttrSetTypeConstraint TextAttributesPropertyInfo = (~) Pango.AttrList.AttrList
    type AttrTransferTypeConstraint TextAttributesPropertyInfo = (~) Pango.AttrList.AttrList
    type AttrTransferType TextAttributesPropertyInfo = Pango.AttrList.AttrList
    type AttrGetType TextAttributesPropertyInfo = Pango.AttrList.AttrList
    type AttrLabel TextAttributesPropertyInfo = "attributes"
    type AttrOrigin TextAttributesPropertyInfo = Text
    attrGet = getTextAttributes
    attrSet = setTextAttributes
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextAttributes
    attrClear = clearTextAttributes
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text.attributes"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:attr:attributes"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextBufferPropertyInfo
instance AttrInfo TextBufferPropertyInfo where
    type AttrAllowedOps TextBufferPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextBufferPropertyInfo = IsText
    type AttrSetTypeConstraint TextBufferPropertyInfo = Clutter.TextBuffer.IsTextBuffer
    type AttrTransferTypeConstraint TextBufferPropertyInfo = Clutter.TextBuffer.IsTextBuffer
    type AttrTransferType TextBufferPropertyInfo = Clutter.TextBuffer.TextBuffer
    type AttrGetType TextBufferPropertyInfo = Clutter.TextBuffer.TextBuffer
    type AttrLabel TextBufferPropertyInfo = "buffer"
    type AttrOrigin TextBufferPropertyInfo = Text
    attrGet = getTextBuffer
    attrSet = setTextBuffer
    attrTransfer _ v = do
        unsafeCastTo Clutter.TextBuffer.TextBuffer v
    attrConstruct = constructTextBuffer
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text.buffer"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:attr:buffer"
        })
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- VVV Prop "cursor-position"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@cursor-position@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' text #cursorPosition
-- @
getTextCursorPosition :: (MonadIO m, IsText o) => o -> m Int32
getTextCursorPosition :: forall (m :: * -> *) o. (MonadIO m, IsText o) => o -> m Int32
getTextCursorPosition o
obj = IO Int32 -> m Int32
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
"cursor-position"

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

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

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

-- VVV Prop "cursor-size"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@cursor-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' text #cursorSize
-- @
getTextCursorSize :: (MonadIO m, IsText o) => o -> m Int32
getTextCursorSize :: forall (m :: * -> *) o. (MonadIO m, IsText o) => o -> m Int32
getTextCursorSize o
obj = IO Int32 -> m Int32
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
"cursor-size"

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

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

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

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

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

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

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

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

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

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

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

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

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

-- VVV Prop "ellipsize"
   -- Type: TInterface (Name {namespace = "Pango", name = "EllipsizeMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

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

-- VVV Prop "font-description"
   -- Type: TInterface (Name {namespace = "Pango", name = "FontDescription"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextFontDescriptionPropertyInfo
instance AttrInfo TextFontDescriptionPropertyInfo where
    type AttrAllowedOps TextFontDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextFontDescriptionPropertyInfo = IsText
    type AttrSetTypeConstraint TextFontDescriptionPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrTransferTypeConstraint TextFontDescriptionPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrTransferType TextFontDescriptionPropertyInfo = Pango.FontDescription.FontDescription
    type AttrGetType TextFontDescriptionPropertyInfo = (Maybe Pango.FontDescription.FontDescription)
    type AttrLabel TextFontDescriptionPropertyInfo = "font-description"
    type AttrOrigin TextFontDescriptionPropertyInfo = Text
    attrGet = getTextFontDescription
    attrSet = setTextFontDescription
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextFontDescription
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text.fontDescription"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:attr:fontDescription"
        })
#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextFontNamePropertyInfo
instance AttrInfo TextFontNamePropertyInfo where
    type AttrAllowedOps TextFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TextFontNamePropertyInfo = IsText
    type AttrSetTypeConstraint TextFontNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TextFontNamePropertyInfo = (~) T.Text
    type AttrTransferType TextFontNamePropertyInfo = T.Text
    type AttrGetType TextFontNamePropertyInfo = T.Text
    type AttrLabel TextFontNamePropertyInfo = "font-name"
    type AttrOrigin TextFontNamePropertyInfo = Text
    attrGet = getTextFontName
    attrSet = setTextFontName
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextFontName
    attrClear = clearTextFontName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text.fontName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:attr:fontName"
        })
#endif

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

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

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

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

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

-- VVV Prop "line-alignment"
   -- Type: TInterface (Name {namespace = "Pango", name = "Alignment"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@line-alignment@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' text #lineAlignment
-- @
getTextLineAlignment :: (MonadIO m, IsText o) => o -> m Pango.Enums.Alignment
getTextLineAlignment :: forall (m :: * -> *) o. (MonadIO m, IsText o) => o -> m Alignment
getTextLineAlignment o
obj = IO Alignment -> m Alignment
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Alignment -> m Alignment) -> IO Alignment -> m Alignment
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Alignment
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"line-alignment"

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

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

#if defined(ENABLE_OVERLOADING)
data TextLineAlignmentPropertyInfo
instance AttrInfo TextLineAlignmentPropertyInfo where
    type AttrAllowedOps TextLineAlignmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextLineAlignmentPropertyInfo = IsText
    type AttrSetTypeConstraint TextLineAlignmentPropertyInfo = (~) Pango.Enums.Alignment
    type AttrTransferTypeConstraint TextLineAlignmentPropertyInfo = (~) Pango.Enums.Alignment
    type AttrTransferType TextLineAlignmentPropertyInfo = Pango.Enums.Alignment
    type AttrGetType TextLineAlignmentPropertyInfo = Pango.Enums.Alignment
    type AttrLabel TextLineAlignmentPropertyInfo = "line-alignment"
    type AttrOrigin TextLineAlignmentPropertyInfo = Text
    attrGet = getTextLineAlignment
    attrSet = setTextLineAlignment
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextLineAlignment
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text.lineAlignment"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:attr:lineAlignment"
        })
#endif

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

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

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

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

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

-- VVV Prop "line-wrap-mode"
   -- Type: TInterface (Name {namespace = "Pango", name = "WrapMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@line-wrap-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' text #lineWrapMode
-- @
getTextLineWrapMode :: (MonadIO m, IsText o) => o -> m Pango.Enums.WrapMode
getTextLineWrapMode :: forall (m :: * -> *) o. (MonadIO m, IsText o) => o -> m WrapMode
getTextLineWrapMode o
obj = IO WrapMode -> m WrapMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO WrapMode -> m WrapMode) -> IO WrapMode -> m WrapMode
forall a b. (a -> b) -> a -> b
$ o -> String -> IO WrapMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"line-wrap-mode"

-- | Set the value of the “@line-wrap-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' text [ #lineWrapMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setTextLineWrapMode :: (MonadIO m, IsText o) => o -> Pango.Enums.WrapMode -> m ()
setTextLineWrapMode :: forall (m :: * -> *) o.
(MonadIO m, IsText o) =>
o -> WrapMode -> m ()
setTextLineWrapMode o
obj WrapMode
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> WrapMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"line-wrap-mode" WrapMode
val

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

#if defined(ENABLE_OVERLOADING)
data TextLineWrapModePropertyInfo
instance AttrInfo TextLineWrapModePropertyInfo where
    type AttrAllowedOps TextLineWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextLineWrapModePropertyInfo = IsText
    type AttrSetTypeConstraint TextLineWrapModePropertyInfo = (~) Pango.Enums.WrapMode
    type AttrTransferTypeConstraint TextLineWrapModePropertyInfo = (~) Pango.Enums.WrapMode
    type AttrTransferType TextLineWrapModePropertyInfo = Pango.Enums.WrapMode
    type AttrGetType TextLineWrapModePropertyInfo = Pango.Enums.WrapMode
    type AttrLabel TextLineWrapModePropertyInfo = "line-wrap-mode"
    type AttrOrigin TextLineWrapModePropertyInfo = Text
    attrGet = getTextLineWrapMode
    attrSet = setTextLineWrapMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextLineWrapMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text.lineWrapMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:attr:lineWrapMode"
        })
#endif

-- VVV Prop "max-length"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@max-length@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' text #maxLength
-- @
getTextMaxLength :: (MonadIO m, IsText o) => o -> m Int32
getTextMaxLength :: forall (m :: * -> *) o. (MonadIO m, IsText o) => o -> m Int32
getTextMaxLength o
obj = IO Int32 -> m Int32
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
"max-length"

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

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

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

-- VVV Prop "password-char"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextSelectedTextColorPropertyInfo
instance AttrInfo TextSelectedTextColorPropertyInfo where
    type AttrAllowedOps TextSelectedTextColorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TextSelectedTextColorPropertyInfo = IsText
    type AttrSetTypeConstraint TextSelectedTextColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferTypeConstraint TextSelectedTextColorPropertyInfo = (~) Clutter.Color.Color
    type AttrTransferType TextSelectedTextColorPropertyInfo = Clutter.Color.Color
    type AttrGetType TextSelectedTextColorPropertyInfo = (Maybe Clutter.Color.Color)
    type AttrLabel TextSelectedTextColorPropertyInfo = "selected-text-color"
    type AttrOrigin TextSelectedTextColorPropertyInfo = Text
    attrGet = getTextSelectedTextColor
    attrSet = setTextSelectedTextColor
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextSelectedTextColor
    attrClear = clearTextSelectedTextColor
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.Text.selectedTextColor"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-Text.html#g:attr:selectedTextColor"
        })
#endif

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

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

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

-- VVV Prop "selection-bound"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@selection-bound@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' text #selectionBound
-- @
getTextSelectionBound :: (MonadIO m, IsText o) => o -> m Int32
getTextSelectionBound :: forall (m :: * -> *) o. (MonadIO m, IsText o) => o -> m Int32
getTextSelectionBound o
obj = IO Int32 -> m Int32
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
"selection-bound"

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

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

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

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

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

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

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

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

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

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

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

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

-- VVV Prop "single-line-mode"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Text
type instance O.AttributeList Text = TextAttributeList
type TextAttributeList = ('[ '("actions", Clutter.Actor.ActorActionsPropertyInfo), '("activatable", TextActivatablePropertyInfo), '("allocation", Clutter.Actor.ActorAllocationPropertyInfo), '("anchorGravity", Clutter.Actor.ActorAnchorGravityPropertyInfo), '("anchorX", Clutter.Actor.ActorAnchorXPropertyInfo), '("anchorY", Clutter.Actor.ActorAnchorYPropertyInfo), '("attributes", TextAttributesPropertyInfo), '("backgroundColor", Clutter.Actor.ActorBackgroundColorPropertyInfo), '("backgroundColorSet", Clutter.Actor.ActorBackgroundColorSetPropertyInfo), '("buffer", TextBufferPropertyInfo), '("childTransform", Clutter.Actor.ActorChildTransformPropertyInfo), '("childTransformSet", Clutter.Actor.ActorChildTransformSetPropertyInfo), '("clip", Clutter.Actor.ActorClipPropertyInfo), '("clipRect", Clutter.Actor.ActorClipRectPropertyInfo), '("clipToAllocation", Clutter.Actor.ActorClipToAllocationPropertyInfo), '("color", TextColorPropertyInfo), '("constraints", Clutter.Actor.ActorConstraintsPropertyInfo), '("content", Clutter.Actor.ActorContentPropertyInfo), '("contentBox", Clutter.Actor.ActorContentBoxPropertyInfo), '("contentGravity", Clutter.Actor.ActorContentGravityPropertyInfo), '("contentRepeat", Clutter.Actor.ActorContentRepeatPropertyInfo), '("cursorColor", TextCursorColorPropertyInfo), '("cursorColorSet", TextCursorColorSetPropertyInfo), '("cursorPosition", TextCursorPositionPropertyInfo), '("cursorSize", TextCursorSizePropertyInfo), '("cursorVisible", TextCursorVisiblePropertyInfo), '("depth", Clutter.Actor.ActorDepthPropertyInfo), '("editable", TextEditablePropertyInfo), '("effect", Clutter.Actor.ActorEffectPropertyInfo), '("ellipsize", TextEllipsizePropertyInfo), '("firstChild", Clutter.Actor.ActorFirstChildPropertyInfo), '("fixedPositionSet", Clutter.Actor.ActorFixedPositionSetPropertyInfo), '("fixedX", Clutter.Actor.ActorFixedXPropertyInfo), '("fixedY", Clutter.Actor.ActorFixedYPropertyInfo), '("fontDescription", TextFontDescriptionPropertyInfo), '("fontName", TextFontNamePropertyInfo), '("hasClip", Clutter.Actor.ActorHasClipPropertyInfo), '("hasPointer", Clutter.Actor.ActorHasPointerPropertyInfo), '("height", Clutter.Actor.ActorHeightPropertyInfo), '("justify", TextJustifyPropertyInfo), '("lastChild", Clutter.Actor.ActorLastChildPropertyInfo), '("layoutManager", Clutter.Actor.ActorLayoutManagerPropertyInfo), '("lineAlignment", TextLineAlignmentPropertyInfo), '("lineWrap", TextLineWrapPropertyInfo), '("lineWrapMode", TextLineWrapModePropertyInfo), '("magnificationFilter", Clutter.Actor.ActorMagnificationFilterPropertyInfo), '("mapped", Clutter.Actor.ActorMappedPropertyInfo), '("marginBottom", Clutter.Actor.ActorMarginBottomPropertyInfo), '("marginLeft", Clutter.Actor.ActorMarginLeftPropertyInfo), '("marginRight", Clutter.Actor.ActorMarginRightPropertyInfo), '("marginTop", Clutter.Actor.ActorMarginTopPropertyInfo), '("maxLength", TextMaxLengthPropertyInfo), '("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), '("passwordChar", TextPasswordCharPropertyInfo), '("pivotPoint", Clutter.Actor.ActorPivotPointPropertyInfo), '("pivotPointZ", Clutter.Actor.ActorPivotPointZPropertyInfo), '("position", TextPositionPropertyInfo), '("reactive", Clutter.Actor.ActorReactivePropertyInfo), '("realized", Clutter.Actor.ActorRealizedPropertyInfo), '("requestMode", Clutter.Actor.ActorRequestModePropertyInfo), '("rotationAngleX", Clutter.Actor.ActorRotationAngleXPropertyInfo), '("rotationAngleY", Clutter.Actor.ActorRotationAngleYPropertyInfo), '("rotationAngleZ", Clutter.Actor.ActorRotationAngleZPropertyInfo), '("rotationCenterX", Clutter.Actor.ActorRotationCenterXPropertyInfo), '("rotationCenterY", Clutter.Actor.ActorRotationCenterYPropertyInfo), '("rotationCenterZ", Clutter.Actor.ActorRotationCenterZPropertyInfo), '("rotationCenterZGravity", Clutter.Actor.ActorRotationCenterZGravityPropertyInfo), '("scaleCenterX", Clutter.Actor.ActorScaleCenterXPropertyInfo), '("scaleCenterY", Clutter.Actor.ActorScaleCenterYPropertyInfo), '("scaleGravity", Clutter.Actor.ActorScaleGravityPropertyInfo), '("scaleX", Clutter.Actor.ActorScaleXPropertyInfo), '("scaleY", Clutter.Actor.ActorScaleYPropertyInfo), '("scaleZ", Clutter.Actor.ActorScaleZPropertyInfo), '("selectable", TextSelectablePropertyInfo), '("selectedTextColor", TextSelectedTextColorPropertyInfo), '("selectedTextColorSet", TextSelectedTextColorSetPropertyInfo), '("selectionBound", TextSelectionBoundPropertyInfo), '("selectionColor", TextSelectionColorPropertyInfo), '("selectionColorSet", TextSelectionColorSetPropertyInfo), '("showOnSetParent", Clutter.Actor.ActorShowOnSetParentPropertyInfo), '("singleLineMode", TextSingleLineModePropertyInfo), '("size", Clutter.Actor.ActorSizePropertyInfo), '("text", TextTextPropertyInfo), '("textDirection", Clutter.Actor.ActorTextDirectionPropertyInfo), '("transform", Clutter.Actor.ActorTransformPropertyInfo), '("transformSet", Clutter.Actor.ActorTransformSetPropertyInfo), '("translationX", Clutter.Actor.ActorTranslationXPropertyInfo), '("translationY", Clutter.Actor.ActorTranslationYPropertyInfo), '("translationZ", Clutter.Actor.ActorTranslationZPropertyInfo), '("useMarkup", TextUseMarkupPropertyInfo), '("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)
textActivatable :: AttrLabelProxy "activatable"
textActivatable = AttrLabelProxy

textAttributes :: AttrLabelProxy "attributes"
textAttributes = AttrLabelProxy

textBuffer :: AttrLabelProxy "buffer"
textBuffer = AttrLabelProxy

textColor :: AttrLabelProxy "color"
textColor = AttrLabelProxy

textCursorColor :: AttrLabelProxy "cursorColor"
textCursorColor = AttrLabelProxy

textCursorColorSet :: AttrLabelProxy "cursorColorSet"
textCursorColorSet = AttrLabelProxy

textCursorPosition :: AttrLabelProxy "cursorPosition"
textCursorPosition = AttrLabelProxy

textCursorSize :: AttrLabelProxy "cursorSize"
textCursorSize = AttrLabelProxy

textCursorVisible :: AttrLabelProxy "cursorVisible"
textCursorVisible = AttrLabelProxy

textEditable :: AttrLabelProxy "editable"
textEditable = AttrLabelProxy

textEllipsize :: AttrLabelProxy "ellipsize"
textEllipsize = AttrLabelProxy

textFontDescription :: AttrLabelProxy "fontDescription"
textFontDescription = AttrLabelProxy

textFontName :: AttrLabelProxy "fontName"
textFontName = AttrLabelProxy

textJustify :: AttrLabelProxy "justify"
textJustify = AttrLabelProxy

textLineAlignment :: AttrLabelProxy "lineAlignment"
textLineAlignment = AttrLabelProxy

textLineWrap :: AttrLabelProxy "lineWrap"
textLineWrap = AttrLabelProxy

textLineWrapMode :: AttrLabelProxy "lineWrapMode"
textLineWrapMode = AttrLabelProxy

textMaxLength :: AttrLabelProxy "maxLength"
textMaxLength = AttrLabelProxy

textPasswordChar :: AttrLabelProxy "passwordChar"
textPasswordChar = AttrLabelProxy

textPosition :: AttrLabelProxy "position"
textPosition = AttrLabelProxy

textSelectable :: AttrLabelProxy "selectable"
textSelectable = AttrLabelProxy

textSelectedTextColor :: AttrLabelProxy "selectedTextColor"
textSelectedTextColor = AttrLabelProxy

textSelectedTextColorSet :: AttrLabelProxy "selectedTextColorSet"
textSelectedTextColorSet = AttrLabelProxy

textSelectionBound :: AttrLabelProxy "selectionBound"
textSelectionBound = AttrLabelProxy

textSelectionColor :: AttrLabelProxy "selectionColor"
textSelectionColor = AttrLabelProxy

textSelectionColorSet :: AttrLabelProxy "selectionColorSet"
textSelectionColorSet = AttrLabelProxy

textSingleLineMode :: AttrLabelProxy "singleLineMode"
textSingleLineMode = AttrLabelProxy

textText :: AttrLabelProxy "text"
textText = AttrLabelProxy

textUseMarkup :: AttrLabelProxy "useMarkup"
textUseMarkup = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Text = TextSignalList
type TextSignalList = ('[ '("activate", TextActivateSignalInfo), '("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), '("cursorChanged", TextCursorChangedSignalInfo), '("cursorEvent", TextCursorEventSignalInfo), '("deleteText", TextDeleteTextSignalInfo), '("destroy", Clutter.Actor.ActorDestroySignalInfo), '("enterEvent", Clutter.Actor.ActorEnterEventSignalInfo), '("event", Clutter.Actor.ActorEventSignalInfo), '("hide", Clutter.Actor.ActorHideSignalInfo), '("insertText", TextInsertTextSignalInfo), '("keyFocusIn", Clutter.Actor.ActorKeyFocusInSignalInfo), '("keyFocusOut", Clutter.Actor.ActorKeyFocusOutSignalInfo), '("keyPressEvent", Clutter.Actor.ActorKeyPressEventSignalInfo), '("keyReleaseEvent", Clutter.Actor.ActorKeyReleaseEventSignalInfo), '("leaveEvent", Clutter.Actor.ActorLeaveEventSignalInfo), '("motionEvent", Clutter.Actor.ActorMotionEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paint", Clutter.Actor.ActorPaintSignalInfo), '("parentSet", Clutter.Actor.ActorParentSetSignalInfo), '("pick", Clutter.Actor.ActorPickSignalInfo), '("queueRedraw", Clutter.Actor.ActorQueueRedrawSignalInfo), '("queueRelayout", Clutter.Actor.ActorQueueRelayoutSignalInfo), '("realize", Clutter.Actor.ActorRealizeSignalInfo), '("scrollEvent", Clutter.Actor.ActorScrollEventSignalInfo), '("show", Clutter.Actor.ActorShowSignalInfo), '("textChanged", TextTextChangedSignalInfo), '("touchEvent", Clutter.Actor.ActorTouchEventSignalInfo), '("transitionStopped", Clutter.Actor.ActorTransitionStoppedSignalInfo), '("transitionsCompleted", Clutter.Actor.ActorTransitionsCompletedSignalInfo), '("unrealize", Clutter.Actor.ActorUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "clutter_text_new" clutter_text_new :: 
    IO (Ptr Text)

-- | Creates a new t'GI.Clutter.Objects.Text.Text' actor. This actor can be used to
-- display and edit text.
-- 
-- /Since: 1.0/
textNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Text
    -- ^ __Returns:__ the newly created t'GI.Clutter.Objects.Text.Text' actor
textNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Text
textNew  = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
result <- IO (Ptr Text)
clutter_text_new
    Text -> Ptr Text -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textNew" Ptr Text
result
    Text
result' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
Text) Ptr Text
result
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Text::new_full
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "font_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string with a font description"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the contents of the actor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the color to be used to render @text"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Text" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_new_full" clutter_text_new_full :: 
    CString ->                              -- font_name : TBasicType TUTF8
    CString ->                              -- text : TBasicType TUTF8
    Ptr Clutter.Color.Color ->              -- color : TInterface (Name {namespace = "Clutter", name = "Color"})
    IO (Ptr Text)

-- | Creates a new t'GI.Clutter.Objects.Text.Text' actor, using /@fontName@/ as the font
-- description; /@text@/ will be used to set the contents of the actor;
-- and /@color@/ will be used as the color to render /@text@/.
-- 
-- This function is equivalent to calling 'GI.Clutter.Objects.Text.textNew',
-- 'GI.Clutter.Objects.Text.textSetFontName', 'GI.Clutter.Objects.Text.textSetText' and
-- 'GI.Clutter.Objects.Text.textSetColor'.
-- 
-- /Since: 1.0/
textNewFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@fontName@/: a string with a font description
    -> T.Text
    -- ^ /@text@/: the contents of the actor
    -> Clutter.Color.Color
    -- ^ /@color@/: the color to be used to render /@text@/
    -> m Text
    -- ^ __Returns:__ the newly created t'GI.Clutter.Objects.Text.Text' actor
textNewFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> Color -> m Text
textNewFull Text
fontName Text
text Color
color = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    CString
fontName' <- Text -> IO CString
textToCString Text
fontName
    CString
text' <- Text -> IO CString
textToCString Text
text
    Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
    Ptr Text
result <- CString -> CString -> Ptr Color -> IO (Ptr Text)
clutter_text_new_full CString
fontName' CString
text' Ptr Color
color'
    Text -> Ptr Text -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textNewFull" Ptr Text
result
    Text
result' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
Text) Ptr Text
result
    Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
fontName'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
text'
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Text::new_with_buffer
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "TextBuffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The buffer to use for the new #ClutterText."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Text" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_new_with_buffer" clutter_text_new_with_buffer :: 
    Ptr Clutter.TextBuffer.TextBuffer ->    -- buffer : TInterface (Name {namespace = "Clutter", name = "TextBuffer"})
    IO (Ptr Text)

-- | Creates a new entry with the specified text buffer.
-- 
-- /Since: 1.10/
textNewWithBuffer ::
    (B.CallStack.HasCallStack, MonadIO m, Clutter.TextBuffer.IsTextBuffer a) =>
    a
    -- ^ /@buffer@/: The buffer to use for the new t'GI.Clutter.Objects.Text.Text'.
    -> m Text
    -- ^ __Returns:__ a new t'GI.Clutter.Objects.Text.Text'
textNewWithBuffer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextBuffer a) =>
a -> m Text
textNewWithBuffer a
buffer = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextBuffer
buffer' <- a -> IO (Ptr TextBuffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr Text
result <- Ptr TextBuffer -> IO (Ptr Text)
clutter_text_new_with_buffer Ptr TextBuffer
buffer'
    Text -> Ptr Text -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textNewWithBuffer" Ptr Text
result
    Text
result' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
Text) Ptr Text
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Text::new_with_text
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "font_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string with a font description"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the contents of the actor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Text" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_new_with_text" clutter_text_new_with_text :: 
    CString ->                              -- font_name : TBasicType TUTF8
    CString ->                              -- text : TBasicType TUTF8
    IO (Ptr Text)

-- | Creates a new t'GI.Clutter.Objects.Text.Text' actor, using /@fontName@/ as the font
-- description; /@text@/ will be used to set the contents of the actor.
-- 
-- This function is equivalent to calling 'GI.Clutter.Objects.Text.textNew',
-- 'GI.Clutter.Objects.Text.textSetFontName', and 'GI.Clutter.Objects.Text.textSetText'.
-- 
-- /Since: 1.0/
textNewWithText ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    -- ^ /@fontName@/: a string with a font description
    -> T.Text
    -- ^ /@text@/: the contents of the actor
    -> m Text
    -- ^ __Returns:__ the newly created t'GI.Clutter.Objects.Text.Text' actor
textNewWithText :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> Text -> m Text
textNewWithText Maybe Text
fontName Text
text = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    CString
maybeFontName <- case Maybe Text
fontName of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFontName -> do
            CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontName'
    CString
text' <- Text -> IO CString
textToCString Text
text
    Ptr Text
result <- CString -> CString -> IO (Ptr Text)
clutter_text_new_with_text CString
maybeFontName CString
text'
    Text -> Ptr Text -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textNewWithText" Ptr Text
result
    Text
result' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
Text) Ptr Text
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontName
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
text'
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Text::activate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_activate" clutter_text_activate :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

-- | Emits the [activate]("GI.Clutter.Objects.Text#g:signal:activate") signal, if /@self@/ has been set
-- as activatable using 'GI.Clutter.Objects.Text.textSetActivatable'.
-- 
-- This function can be used to emit the [activate](#g:signal:activate) signal inside
-- a [capturedEvent]("GI.Clutter.Objects.Actor#g:signal:capturedEvent") or [keyPressEvent]("GI.Clutter.Objects.Actor#g:signal:keyPressEvent")
-- signal handlers before the default signal handler for the
-- t'GI.Clutter.Objects.Text.Text' is invoked.
-- 
-- /Since: 1.0/
textActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the [activate](#g:signal:activate) signal has been emitted,
    --   and 'P.False' otherwise
textActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Bool
textActivate a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Text -> IO CInt
clutter_text_activate Ptr Text
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextActivateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextActivateMethodInfo a signature where
    overloadedMethod = textActivate

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


#endif

-- method Text::coords_to_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the X coordinate, relative to the actor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Y coordinate, relative to the actor"
--                 , 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_text_coords_to_position" clutter_text_coords_to_position :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO Int32

-- | Retrieves the position of the character at the given coordinates.
-- 
-- /Since: 1.10/
textCoordsToPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Float
    -- ^ /@x@/: the X coordinate, relative to the actor
    -> Float
    -- ^ /@y@/: the Y coordinate, relative to the actor
    -> m Int32
    -- ^ __Returns:__ the position of the character
textCoordsToPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Float -> Float -> m Int32
textCoordsToPosition a
self Float
x Float
y = IO Int32 -> m Int32
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 Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    Int32
result <- Ptr Text -> CFloat -> CFloat -> IO Int32
clutter_text_coords_to_position Ptr Text
self' CFloat
x' CFloat
y'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TextCoordsToPositionMethodInfo
instance (signature ~ (Float -> Float -> m Int32), MonadIO m, IsText a) => O.OverloadedMethod TextCoordsToPositionMethodInfo a signature where
    overloadedMethod = textCoordsToPosition

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


#endif

-- method Text::delete_chars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_chars"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of characters to delete"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_delete_chars" clutter_text_delete_chars :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Word32 ->                               -- n_chars : TBasicType TUInt
    IO ()

-- | Deletes /@nChars@/ inside a t'GI.Clutter.Objects.Text.Text' actor, starting from the
-- current cursor position.
-- 
-- Somewhat awkwardly, the cursor position is decremented by the same
-- number of characters you\'ve deleted.
-- 
-- /Since: 1.0/
textDeleteChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Word32
    -- ^ /@nChars@/: the number of characters to delete
    -> m ()
textDeleteChars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Word32 -> m ()
textDeleteChars a
self Word32
nChars = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Text -> Word32 -> IO ()
clutter_text_delete_chars Ptr Text
self' Word32
nChars
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextDeleteCharsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextDeleteCharsMethodInfo a signature where
    overloadedMethod = textDeleteChars

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


#endif

-- method Text::delete_selection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_delete_selection" clutter_text_delete_selection :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

-- | Deletes the currently selected text
-- 
-- This function is only useful in subclasses of t'GI.Clutter.Objects.Text.Text'
-- 
-- /Since: 1.0/
textDeleteSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if text was deleted or if the text actor
    --   is empty, and 'P.False' otherwise
textDeleteSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Bool
textDeleteSelection a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Text -> IO CInt
clutter_text_delete_selection Ptr Text
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextDeleteSelectionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextDeleteSelectionMethodInfo a signature where
    overloadedMethod = textDeleteSelection

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


#endif

-- method Text::delete_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start_pos"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "starting position" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end_pos"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ending position" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_delete_text" clutter_text_delete_text :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Int64 ->                                -- start_pos : TBasicType TInt64
    Int64 ->                                -- end_pos : TBasicType TInt64
    IO ()

-- | Deletes the text inside a t'GI.Clutter.Objects.Text.Text' actor between /@startPos@/
-- and /@endPos@/.
-- 
-- The starting and ending positions are expressed in characters,
-- not in bytes.
-- 
-- /Since: 1.0/
textDeleteText ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Int64
    -- ^ /@startPos@/: starting position
    -> Int64
    -- ^ /@endPos@/: ending position
    -> m ()
textDeleteText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int64 -> Int64 -> m ()
textDeleteText a
self Int64
startPos Int64
endPos = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Text -> Int64 -> Int64 -> IO ()
clutter_text_delete_text Ptr Text
self' Int64
startPos Int64
endPos
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextDeleteTextMethodInfo
instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextDeleteTextMethodInfo a signature where
    overloadedMethod = textDeleteText

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


#endif

-- method Text::get_activatable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_activatable" clutter_text_get_activatable :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

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

#if defined(ENABLE_OVERLOADING)
data TextGetActivatableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextGetActivatableMethodInfo a signature where
    overloadedMethod = textGetActivatable

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


#endif

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

foreign import ccall "clutter_text_get_attributes" clutter_text_get_attributes :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO (Ptr Pango.AttrList.AttrList)

-- | Gets the attribute list that was set on the t'GI.Clutter.Objects.Text.Text' actor
-- 'GI.Clutter.Objects.Text.textSetAttributes', if any.
-- 
-- /Since: 1.0/
textGetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Pango.AttrList.AttrList
    -- ^ __Returns:__ the attribute list, or 'P.Nothing' if none was set. The
    --  returned value is owned by the t'GI.Clutter.Objects.Text.Text' and should not be unreferenced.
textGetAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m AttrList
textGetAttributes a
self = IO AttrList -> m AttrList
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AttrList -> m AttrList) -> IO AttrList -> m AttrList
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AttrList
result <- Ptr Text -> IO (Ptr AttrList)
clutter_text_get_attributes Ptr Text
self'
    Text -> Ptr AttrList -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetAttributes" Ptr AttrList
result
    AttrList
result' <- ((ManagedPtr AttrList -> AttrList) -> Ptr AttrList -> IO AttrList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr AttrList -> AttrList
Pango.AttrList.AttrList) Ptr AttrList
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    AttrList -> IO AttrList
forall (m :: * -> *) a. Monad m => a -> m a
return AttrList
result'

#if defined(ENABLE_OVERLOADING)
data TextGetAttributesMethodInfo
instance (signature ~ (m Pango.AttrList.AttrList), MonadIO m, IsText a) => O.OverloadedMethod TextGetAttributesMethodInfo a signature where
    overloadedMethod = textGetAttributes

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


#endif

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

foreign import ccall "clutter_text_get_buffer" clutter_text_get_buffer :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO (Ptr Clutter.TextBuffer.TextBuffer)

-- | Get the t'GI.Clutter.Objects.TextBuffer.TextBuffer' object which holds the text for
-- this widget.
-- 
-- /Since: 1.10/
textGetBuffer ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Clutter.TextBuffer.TextBuffer
    -- ^ __Returns:__ A @/GtkEntryBuffer/@ object.
textGetBuffer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m TextBuffer
textGetBuffer a
self = IO TextBuffer -> m TextBuffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextBuffer -> m TextBuffer) -> IO TextBuffer -> m TextBuffer
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TextBuffer
result <- Ptr Text -> IO (Ptr TextBuffer)
clutter_text_get_buffer Ptr Text
self'
    Text -> Ptr TextBuffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetBuffer" Ptr TextBuffer
result
    TextBuffer
result' <- ((ManagedPtr TextBuffer -> TextBuffer)
-> Ptr TextBuffer -> IO TextBuffer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextBuffer -> TextBuffer
Clutter.TextBuffer.TextBuffer) Ptr TextBuffer
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    TextBuffer -> IO TextBuffer
forall (m :: * -> *) a. Monad m => a -> m a
return TextBuffer
result'

#if defined(ENABLE_OVERLOADING)
data TextGetBufferMethodInfo
instance (signature ~ (m Clutter.TextBuffer.TextBuffer), MonadIO m, IsText a) => O.OverloadedMethod TextGetBufferMethodInfo a signature where
    overloadedMethod = textGetBuffer

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


#endif

-- method Text::get_chars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start_pos"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "start of text, in characters"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end_pos"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "end of text, in characters"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_get_chars" clutter_text_get_chars :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Int64 ->                                -- start_pos : TBasicType TInt64
    Int64 ->                                -- end_pos : TBasicType TInt64
    IO CString

-- | Retrieves the contents of the t'GI.Clutter.Objects.Text.Text' actor between
-- /@startPos@/ and /@endPos@/, but not including /@endPos@/.
-- 
-- The positions are specified in characters, not in bytes.
-- 
-- /Since: 1.0/
textGetChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Int64
    -- ^ /@startPos@/: start of text, in characters
    -> Int64
    -- ^ /@endPos@/: end of text, in characters
    -> m T.Text
    -- ^ __Returns:__ a newly allocated string with the contents of
    --   the text actor between the specified positions. Use 'GI.GLib.Functions.free'
    --   to free the resources when done
textGetChars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int64 -> Int64 -> m Text
textGetChars a
self Int64
startPos Int64
endPos = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Text -> Int64 -> Int64 -> IO CString
clutter_text_get_chars Ptr Text
self' Int64
startPos Int64
endPos
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetChars" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TextGetCharsMethodInfo
instance (signature ~ (Int64 -> Int64 -> m T.Text), MonadIO m, IsText a) => O.OverloadedMethod TextGetCharsMethodInfo a signature where
    overloadedMethod = textGetChars

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


#endif

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

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

-- | Retrieves the text color as set by 'GI.Clutter.Objects.Text.textSetColor'.
-- 
-- /Since: 1.0/
textGetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m (Clutter.Color.Color)
textGetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Color
textGetColor a
self = IO Color -> m Color
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
4 :: IO (Ptr Clutter.Color.Color)
    Ptr Text -> Ptr Color -> IO ()
clutter_text_get_color Ptr Text
self' Ptr Color
color
    Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Clutter.Color.Color) Ptr Color
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Color -> IO Color
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'

#if defined(ENABLE_OVERLOADING)
data TextGetColorMethodInfo
instance (signature ~ (m (Clutter.Color.Color)), MonadIO m, IsText a) => O.OverloadedMethod TextGetColorMethodInfo a signature where
    overloadedMethod = textGetColor

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


#endif

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

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

-- | Retrieves the color of the cursor of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.0/
textGetCursorColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m (Clutter.Color.Color)
textGetCursorColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Color
textGetCursorColor a
self = IO Color -> m Color
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
4 :: IO (Ptr Clutter.Color.Color)
    Ptr Text -> Ptr Color -> IO ()
clutter_text_get_cursor_color Ptr Text
self' Ptr Color
color
    Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Clutter.Color.Color) Ptr Color
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Color -> IO Color
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'

#if defined(ENABLE_OVERLOADING)
data TextGetCursorColorMethodInfo
instance (signature ~ (m (Clutter.Color.Color)), MonadIO m, IsText a) => O.OverloadedMethod TextGetCursorColorMethodInfo a signature where
    overloadedMethod = textGetCursorColor

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


#endif

-- method Text::get_cursor_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_cursor_position" clutter_text_get_cursor_position :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO Int32

-- | Retrieves the cursor position.
-- 
-- /Since: 1.0/
textGetCursorPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Int32
    -- ^ __Returns:__ the cursor position, in characters
textGetCursorPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Int32
textGetCursorPosition a
self = IO Int32 -> m Int32
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 Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr Text -> IO Int32
clutter_text_get_cursor_position Ptr Text
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TextGetCursorPositionMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsText a) => O.OverloadedMethod TextGetCursorPositionMethodInfo a signature where
    overloadedMethod = textGetCursorPosition

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


#endif

-- method Text::get_cursor_rect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rect"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Rect" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location of a #ClutterRect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_get_cursor_rect" clutter_text_get_cursor_rect :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Ptr Clutter.Rect.Rect ->                -- rect : TInterface (Name {namespace = "Clutter", name = "Rect"})
    IO ()

-- | Retrieves the rectangle that contains the cursor.
-- 
-- The coordinates of the rectangle\'s origin are in actor-relative
-- coordinates.
-- 
-- /Since: 1.16/
textGetCursorRect ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m (Clutter.Rect.Rect)
textGetCursorRect :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Rect
textGetCursorRect a
self = IO Rect -> m Rect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Rect
rect <- Int -> IO (Ptr Rect)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Clutter.Rect.Rect)
    Ptr Text -> Ptr Rect -> IO ()
clutter_text_get_cursor_rect Ptr Text
self' Ptr Rect
rect
    Rect
rect' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Clutter.Rect.Rect) Ptr Rect
rect
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Rect -> IO Rect
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
rect'

#if defined(ENABLE_OVERLOADING)
data TextGetCursorRectMethodInfo
instance (signature ~ (m (Clutter.Rect.Rect)), MonadIO m, IsText a) => O.OverloadedMethod TextGetCursorRectMethodInfo a signature where
    overloadedMethod = textGetCursorRect

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


#endif

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

foreign import ccall "clutter_text_get_cursor_size" clutter_text_get_cursor_size :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO Word32

-- | Retrieves the size of the cursor of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.0/
textGetCursorSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Word32
    -- ^ __Returns:__ the size of the cursor, in pixels
textGetCursorSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Word32
textGetCursorSize a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Text -> IO Word32
clutter_text_get_cursor_size Ptr Text
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data TextGetCursorSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsText a) => O.OverloadedMethod TextGetCursorSizeMethodInfo a signature where
    overloadedMethod = textGetCursorSize

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


#endif

-- method Text::get_cursor_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_cursor_visible" clutter_text_get_cursor_visible :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

-- | Retrieves whether the cursor of a t'GI.Clutter.Objects.Text.Text' actor is visible.
-- 
-- /Since: 1.0/
textGetCursorVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the cursor is visible
textGetCursorVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Bool
textGetCursorVisible a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Text -> IO CInt
clutter_text_get_cursor_visible Ptr Text
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextGetCursorVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextGetCursorVisibleMethodInfo a signature where
    overloadedMethod = textGetCursorVisible

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


#endif

-- method Text::get_editable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_editable" clutter_text_get_editable :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

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

#if defined(ENABLE_OVERLOADING)
data TextGetEditableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextGetEditableMethodInfo a signature where
    overloadedMethod = textGetEditable

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


#endif

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

foreign import ccall "clutter_text_get_ellipsize" clutter_text_get_ellipsize :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CUInt

-- | Returns the ellipsizing position of a t'GI.Clutter.Objects.Text.Text' actor, as
-- set by 'GI.Clutter.Objects.Text.textSetEllipsize'.
-- 
-- /Since: 1.0/
textGetEllipsize ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Pango.Enums.EllipsizeMode
    -- ^ __Returns:__ t'GI.Pango.Enums.EllipsizeMode'
textGetEllipsize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m EllipsizeMode
textGetEllipsize a
self = IO EllipsizeMode -> m EllipsizeMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EllipsizeMode -> m EllipsizeMode)
-> IO EllipsizeMode -> m EllipsizeMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Text -> IO CUInt
clutter_text_get_ellipsize Ptr Text
self'
    let result' :: EllipsizeMode
result' = (Int -> EllipsizeMode
forall a. Enum a => Int -> a
toEnum (Int -> EllipsizeMode) -> (CUInt -> Int) -> CUInt -> EllipsizeMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    EllipsizeMode -> IO EllipsizeMode
forall (m :: * -> *) a. Monad m => a -> m a
return EllipsizeMode
result'

#if defined(ENABLE_OVERLOADING)
data TextGetEllipsizeMethodInfo
instance (signature ~ (m Pango.Enums.EllipsizeMode), MonadIO m, IsText a) => O.OverloadedMethod TextGetEllipsizeMethodInfo a signature where
    overloadedMethod = textGetEllipsize

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


#endif

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

foreign import ccall "clutter_text_get_font_description" clutter_text_get_font_description :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO (Ptr Pango.FontDescription.FontDescription)

-- | Retrieves the t'GI.Pango.Structs.FontDescription.FontDescription' used by /@self@/
-- 
-- /Since: 1.2/
textGetFontDescription ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Pango.FontDescription.FontDescription
    -- ^ __Returns:__ a t'GI.Pango.Structs.FontDescription.FontDescription'. The returned value is owned
    --   by the t'GI.Clutter.Objects.Text.Text' actor and it should not be modified or freed
textGetFontDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m FontDescription
textGetFontDescription a
self = IO FontDescription -> m FontDescription
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FontDescription -> m FontDescription)
-> IO FontDescription -> m FontDescription
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr FontDescription
result <- Ptr Text -> IO (Ptr FontDescription)
clutter_text_get_font_description Ptr Text
self'
    Text -> Ptr FontDescription -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetFontDescription" Ptr FontDescription
result
    FontDescription
result' <- ((ManagedPtr FontDescription -> FontDescription)
-> Ptr FontDescription -> IO FontDescription
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr FontDescription -> FontDescription
Pango.FontDescription.FontDescription) Ptr FontDescription
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    FontDescription -> IO FontDescription
forall (m :: * -> *) a. Monad m => a -> m a
return FontDescription
result'

#if defined(ENABLE_OVERLOADING)
data TextGetFontDescriptionMethodInfo
instance (signature ~ (m Pango.FontDescription.FontDescription), MonadIO m, IsText a) => O.OverloadedMethod TextGetFontDescriptionMethodInfo a signature where
    overloadedMethod = textGetFontDescription

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


#endif

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

foreign import ccall "clutter_text_get_font_name" clutter_text_get_font_name :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CString

-- | Retrieves the font name as set by 'GI.Clutter.Objects.Text.textSetFontName'.
-- 
-- /Since: 1.0/
textGetFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m T.Text
    -- ^ __Returns:__ a string containing the font name. The returned
    --   string is owned by the t'GI.Clutter.Objects.Text.Text' actor and should not be
    --   modified or freed
textGetFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Text
textGetFontName a
self = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Text -> IO CString
clutter_text_get_font_name Ptr Text
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetFontName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TextGetFontNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsText a) => O.OverloadedMethod TextGetFontNameMethodInfo a signature where
    overloadedMethod = textGetFontName

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


#endif

-- method Text::get_justify
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_justify" clutter_text_get_justify :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

-- | Retrieves whether the t'GI.Clutter.Objects.Text.Text' actor should justify its contents
-- on both margins.
-- 
-- /Since: 0.6/
textGetJustify ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the text should be justified
textGetJustify :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Bool
textGetJustify a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Text -> IO CInt
clutter_text_get_justify Ptr Text
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextGetJustifyMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextGetJustifyMethodInfo a signature where
    overloadedMethod = textGetJustify

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


#endif

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

foreign import ccall "clutter_text_get_layout" clutter_text_get_layout :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO (Ptr Pango.Layout.Layout)

-- | Retrieves the current t'GI.Pango.Objects.Layout.Layout' used by a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.0/
textGetLayout ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Pango.Layout.Layout
    -- ^ __Returns:__ a t'GI.Pango.Objects.Layout.Layout'. The returned object is owned by
    --   the t'GI.Clutter.Objects.Text.Text' actor and should not be modified or freed
textGetLayout :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Layout
textGetLayout a
self = IO Layout -> m Layout
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Layout -> m Layout) -> IO Layout -> m Layout
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Layout
result <- Ptr Text -> IO (Ptr Layout)
clutter_text_get_layout Ptr Text
self'
    Text -> Ptr Layout -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetLayout" Ptr Layout
result
    Layout
result' <- ((ManagedPtr Layout -> Layout) -> Ptr Layout -> IO Layout
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Layout -> Layout
Pango.Layout.Layout) Ptr Layout
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Layout -> IO Layout
forall (m :: * -> *) a. Monad m => a -> m a
return Layout
result'

#if defined(ENABLE_OVERLOADING)
data TextGetLayoutMethodInfo
instance (signature ~ (m Pango.Layout.Layout), MonadIO m, IsText a) => O.OverloadedMethod TextGetLayoutMethodInfo a signature where
    overloadedMethod = textGetLayout

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


#endif

-- method Text::get_layout_offsets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location to store X offset of layout, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location to store Y offset of layout, 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_text_get_layout_offsets" clutter_text_get_layout_offsets :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Ptr Int32 ->                            -- x : TBasicType TInt
    Ptr Int32 ->                            -- y : TBasicType TInt
    IO ()

-- | Obtains the coordinates where the t'GI.Clutter.Objects.Text.Text' will draw the t'GI.Pango.Objects.Layout.Layout'
-- representing the text.
-- 
-- /Since: 1.8/
textGetLayoutOffsets ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m ((Int32, Int32))
textGetLayoutOffsets :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m (Int32, Int32)
textGetLayoutOffsets a
self = IO (Int32, Int32) -> m (Int32, Int32)
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 Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Int32
x <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
y <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Text -> Ptr Int32 -> Ptr Int32 -> IO ()
clutter_text_get_layout_offsets Ptr Text
self' Ptr Int32
x Ptr Int32
y
    Int32
x' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
x
    Int32
y' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
y
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
x
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
y
    (Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
x', Int32
y')

#if defined(ENABLE_OVERLOADING)
data TextGetLayoutOffsetsMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsText a) => O.OverloadedMethod TextGetLayoutOffsetsMethodInfo a signature where
    overloadedMethod = textGetLayoutOffsets

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


#endif

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

foreign import ccall "clutter_text_get_line_alignment" clutter_text_get_line_alignment :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CUInt

-- | Retrieves the alignment of a t'GI.Clutter.Objects.Text.Text', as set by
-- 'GI.Clutter.Objects.Text.textSetLineAlignment'.
-- 
-- /Since: 1.0/
textGetLineAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Pango.Enums.Alignment
    -- ^ __Returns:__ a t'GI.Pango.Enums.Alignment'
textGetLineAlignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Alignment
textGetLineAlignment a
self = IO Alignment -> m Alignment
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Alignment -> m Alignment) -> IO Alignment -> m Alignment
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Text -> IO CUInt
clutter_text_get_line_alignment Ptr Text
self'
    let result' :: Alignment
result' = (Int -> Alignment
forall a. Enum a => Int -> a
toEnum (Int -> Alignment) -> (CUInt -> Int) -> CUInt -> Alignment
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Alignment -> IO Alignment
forall (m :: * -> *) a. Monad m => a -> m a
return Alignment
result'

#if defined(ENABLE_OVERLOADING)
data TextGetLineAlignmentMethodInfo
instance (signature ~ (m Pango.Enums.Alignment), MonadIO m, IsText a) => O.OverloadedMethod TextGetLineAlignmentMethodInfo a signature where
    overloadedMethod = textGetLineAlignment

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


#endif

-- method Text::get_line_wrap
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_line_wrap" clutter_text_get_line_wrap :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

-- | Retrieves the value set using 'GI.Clutter.Objects.Text.textSetLineWrap'.
-- 
-- /Since: 1.0/
textGetLineWrap ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Text.Text' actor should wrap
    --   its contents
textGetLineWrap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Bool
textGetLineWrap a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Text -> IO CInt
clutter_text_get_line_wrap Ptr Text
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextGetLineWrapMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextGetLineWrapMethodInfo a signature where
    overloadedMethod = textGetLineWrap

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


#endif

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

foreign import ccall "clutter_text_get_line_wrap_mode" clutter_text_get_line_wrap_mode :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CUInt

-- | Retrieves the line wrap mode used by the t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- See clutter_text_set_line_wrap_mode ().
-- 
-- /Since: 1.0/
textGetLineWrapMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Pango.Enums.WrapMode
    -- ^ __Returns:__ the wrap mode used by the t'GI.Clutter.Objects.Text.Text'
textGetLineWrapMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m WrapMode
textGetLineWrapMode a
self = IO WrapMode -> m WrapMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WrapMode -> m WrapMode) -> IO WrapMode -> m WrapMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Text -> IO CUInt
clutter_text_get_line_wrap_mode Ptr Text
self'
    let result' :: WrapMode
result' = (Int -> WrapMode
forall a. Enum a => Int -> a
toEnum (Int -> WrapMode) -> (CUInt -> Int) -> CUInt -> WrapMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    WrapMode -> IO WrapMode
forall (m :: * -> *) a. Monad m => a -> m a
return WrapMode
result'

#if defined(ENABLE_OVERLOADING)
data TextGetLineWrapModeMethodInfo
instance (signature ~ (m Pango.Enums.WrapMode), MonadIO m, IsText a) => O.OverloadedMethod TextGetLineWrapModeMethodInfo a signature where
    overloadedMethod = textGetLineWrapMode

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


#endif

-- method Text::get_max_length
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_max_length" clutter_text_get_max_length :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO Int32

-- | Gets the maximum length of text that can be set into a text actor.
-- 
-- See 'GI.Clutter.Objects.Text.textSetMaxLength'.
-- 
-- /Since: 1.0/
textGetMaxLength ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Int32
    -- ^ __Returns:__ the maximum number of characters.
textGetMaxLength :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Int32
textGetMaxLength a
self = IO Int32 -> m Int32
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 Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr Text -> IO Int32
clutter_text_get_max_length Ptr Text
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TextGetMaxLengthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsText a) => O.OverloadedMethod TextGetMaxLengthMethodInfo a signature where
    overloadedMethod = textGetMaxLength

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


#endif

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

foreign import ccall "clutter_text_get_password_char" clutter_text_get_password_char :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

-- | Retrieves the character to use in place of the actual text
-- as set by 'GI.Clutter.Objects.Text.textSetPasswordChar'.
-- 
-- /Since: 1.0/
textGetPasswordChar ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Char
    -- ^ __Returns:__ a Unicode character or 0 if the password
    --   character is not set
textGetPasswordChar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Char
textGetPasswordChar a
self = IO Char -> m Char
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Char -> m Char) -> IO Char -> m Char
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Text -> IO CInt
clutter_text_get_password_char Ptr Text
self'
    let result' :: Char
result' = (Int -> Char
chr (Int -> Char) -> (CInt -> Int) -> CInt -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Char -> IO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
result'

#if defined(ENABLE_OVERLOADING)
data TextGetPasswordCharMethodInfo
instance (signature ~ (m Char), MonadIO m, IsText a) => O.OverloadedMethod TextGetPasswordCharMethodInfo a signature where
    overloadedMethod = textGetPasswordChar

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


#endif

-- method Text::get_selectable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_selectable" clutter_text_get_selectable :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

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

#if defined(ENABLE_OVERLOADING)
data TextGetSelectableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextGetSelectableMethodInfo a signature where
    overloadedMethod = textGetSelectable

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


#endif

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

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

-- | Retrieves the color of selected text of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.8/
textGetSelectedTextColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m (Clutter.Color.Color)
textGetSelectedTextColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Color
textGetSelectedTextColor a
self = IO Color -> m Color
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
4 :: IO (Ptr Clutter.Color.Color)
    Ptr Text -> Ptr Color -> IO ()
clutter_text_get_selected_text_color Ptr Text
self' Ptr Color
color
    Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Clutter.Color.Color) Ptr Color
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Color -> IO Color
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'

#if defined(ENABLE_OVERLOADING)
data TextGetSelectedTextColorMethodInfo
instance (signature ~ (m (Clutter.Color.Color)), MonadIO m, IsText a) => O.OverloadedMethod TextGetSelectedTextColorMethodInfo a signature where
    overloadedMethod = textGetSelectedTextColor

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


#endif

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

foreign import ccall "clutter_text_get_selection" clutter_text_get_selection :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CString

-- | Retrieves the currently selected text.
-- 
-- /Since: 1.0/
textGetSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m T.Text
    -- ^ __Returns:__ a newly allocated string containing the currently
    --   selected text, or 'P.Nothing'. Use 'GI.GLib.Functions.free' to free the returned
    --   string.
textGetSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Text
textGetSelection a
self = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Text -> IO CString
clutter_text_get_selection Ptr Text
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetSelection" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TextGetSelectionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsText a) => O.OverloadedMethod TextGetSelectionMethodInfo a signature where
    overloadedMethod = textGetSelection

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


#endif

-- method Text::get_selection_bound
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_selection_bound" clutter_text_get_selection_bound :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO Int32

-- | Retrieves the other end of the selection of a t'GI.Clutter.Objects.Text.Text' actor,
-- in characters from the current cursor position.
-- 
-- /Since: 1.0/
textGetSelectionBound ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Int32
    -- ^ __Returns:__ the position of the other end of the selection
textGetSelectionBound :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Int32
textGetSelectionBound a
self = IO Int32 -> m Int32
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 Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr Text -> IO Int32
clutter_text_get_selection_bound Ptr Text
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TextGetSelectionBoundMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsText a) => O.OverloadedMethod TextGetSelectionBoundMethodInfo a signature where
    overloadedMethod = textGetSelectionBound

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


#endif

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

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

-- | Retrieves the color of the selection of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.0/
textGetSelectionColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m (Clutter.Color.Color)
textGetSelectionColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Color
textGetSelectionColor a
self = IO Color -> m Color
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
4 :: IO (Ptr Clutter.Color.Color)
    Ptr Text -> Ptr Color -> IO ()
clutter_text_get_selection_color Ptr Text
self' Ptr Color
color
    Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Clutter.Color.Color) Ptr Color
color
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Color -> IO Color
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'

#if defined(ENABLE_OVERLOADING)
data TextGetSelectionColorMethodInfo
instance (signature ~ (m (Clutter.Color.Color)), MonadIO m, IsText a) => O.OverloadedMethod TextGetSelectionColorMethodInfo a signature where
    overloadedMethod = textGetSelectionColor

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


#endif

-- method Text::get_single_line_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_single_line_mode" clutter_text_get_single_line_mode :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

-- | Retrieves whether the t'GI.Clutter.Objects.Text.Text' actor is in single line mode.
-- 
-- /Since: 1.0/
textGetSingleLineMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the t'GI.Clutter.Objects.Text.Text' actor is in single line mode
textGetSingleLineMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Bool
textGetSingleLineMode a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Text -> IO CInt
clutter_text_get_single_line_mode Ptr Text
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextGetSingleLineModeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextGetSingleLineModeMethodInfo a signature where
    overloadedMethod = textGetSingleLineMode

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


#endif

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

foreign import ccall "clutter_text_get_text" clutter_text_get_text :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CString

-- | Retrieves a pointer to the current contents of a t'GI.Clutter.Objects.Text.Text'
-- actor.
-- 
-- If you need a copy of the contents for manipulating, either
-- use 'GI.GLib.Functions.strdup' on the returned string, or use:
-- 
-- >
-- >   copy = clutter_text_get_chars (text, 0, -1);
-- 
-- 
-- Which will return a newly allocated string.
-- 
-- If the t'GI.Clutter.Objects.Text.Text' actor is empty, this function will return
-- an empty string, and not 'P.Nothing'.
-- 
-- /Since: 1.0/
textGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m T.Text
    -- ^ __Returns:__ the contents of the actor. The returned
    --   string is owned by the t'GI.Clutter.Objects.Text.Text' actor and should never be modified
    --   or freed
textGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Text
textGetText a
self = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Text -> IO CString
clutter_text_get_text Ptr Text
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textGetText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TextGetTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsText a) => O.OverloadedMethod TextGetTextMethodInfo a signature where
    overloadedMethod = textGetText

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


#endif

-- method Text::get_use_markup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , 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_text_get_use_markup" clutter_text_get_use_markup :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    IO CInt

-- | Retrieves whether the contents of the t'GI.Clutter.Objects.Text.Text' actor should be
-- parsed for the Pango text markup.
-- 
-- /Since: 1.0/
textGetUseMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the contents will be parsed for markup
textGetUseMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> m Bool
textGetUseMarkup a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Text -> IO CInt
clutter_text_get_use_markup Ptr Text
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TextGetUseMarkupMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsText a) => O.OverloadedMethod TextGetUseMarkupMethodInfo a signature where
    overloadedMethod = textGetUseMarkup

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


#endif

-- method Text::insert_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the text to be inserted"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position of the insertion, or -1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_insert_text" clutter_text_insert_text :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CString ->                              -- text : TBasicType TUTF8
    Int64 ->                                -- position : TBasicType TInt64
    IO ()

-- | Inserts /@text@/ into a t'GI.Clutter.Objects.Actor.Actor' at the given position.
-- 
-- If /@position@/ is a negative number, the text will be appended
-- at the end of the current contents of the t'GI.Clutter.Objects.Text.Text'.
-- 
-- The position is expressed in characters, not in bytes.
-- 
-- /Since: 1.0/
textInsertText ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> T.Text
    -- ^ /@text@/: the text to be inserted
    -> Int64
    -- ^ /@position@/: the position of the insertion, or -1
    -> m ()
textInsertText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Text -> Int64 -> m ()
textInsertText a
self Text
text Int64
position = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
text' <- Text -> IO CString
textToCString Text
text
    Ptr Text -> CString -> Int64 -> IO ()
clutter_text_insert_text Ptr Text
self' CString
text' Int64
position
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
text'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextInsertTextMethodInfo
instance (signature ~ (T.Text -> Int64 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextInsertTextMethodInfo a signature where
    overloadedMethod = textInsertText

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


#endif

-- method Text::insert_unichar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wc"
--           , argType = TBasicType TUniChar
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a Unicode character"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_insert_unichar" clutter_text_insert_unichar :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- wc : TBasicType TUniChar
    IO ()

-- | Inserts /@wc@/ at the current cursor position of a
-- t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.0/
textInsertUnichar ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Char
    -- ^ /@wc@/: a Unicode character
    -> m ()
textInsertUnichar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Char -> m ()
textInsertUnichar a
self Char
wc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let wc' :: CInt
wc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord) Char
wc
    Ptr Text -> CInt -> IO ()
clutter_text_insert_unichar Ptr Text
self' CInt
wc'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextInsertUnicharMethodInfo
instance (signature ~ (Char -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextInsertUnicharMethodInfo a signature where
    overloadedMethod = textInsertUnichar

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


#endif

-- method Text::position_to_coords
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "position in characters"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the X coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the Y coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "line_height"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the line height, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_position_to_coords" clutter_text_position_to_coords :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Int32 ->                                -- position : TBasicType TInt
    Ptr CFloat ->                           -- x : TBasicType TFloat
    Ptr CFloat ->                           -- y : TBasicType TFloat
    Ptr CFloat ->                           -- line_height : TBasicType TFloat
    IO CInt

-- | Retrieves the coordinates of the given /@position@/.
-- 
-- /Since: 1.0/
textPositionToCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Int32
    -- ^ /@position@/: position in characters
    -> m ((Bool, Float, Float, Float))
    -- ^ __Returns:__ 'P.True' if the conversion was successful
textPositionToCoords :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m (Bool, Float, Float, Float)
textPositionToCoords a
self Int32
position = IO (Bool, Float, Float, Float) -> m (Bool, Float, Float, Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Float, Float, Float) -> m (Bool, Float, Float, Float))
-> IO (Bool, Float, Float, Float) -> m (Bool, Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
x <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
y <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
lineHeight <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    CInt
result <- Ptr Text
-> Int32 -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO CInt
clutter_text_position_to_coords Ptr Text
self' Int32
position Ptr CFloat
x Ptr CFloat
y Ptr CFloat
lineHeight
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CFloat
x' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
x
    let x'' :: Float
x'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x'
    CFloat
y' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
y
    let y'' :: Float
y'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y'
    CFloat
lineHeight' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
lineHeight
    let lineHeight'' :: Float
lineHeight'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
lineHeight'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
x
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
y
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
lineHeight
    (Bool, Float, Float, Float) -> IO (Bool, Float, Float, Float)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Float
x'', Float
y'', Float
lineHeight'')

#if defined(ENABLE_OVERLOADING)
data TextPositionToCoordsMethodInfo
instance (signature ~ (Int32 -> m ((Bool, Float, Float, Float))), MonadIO m, IsText a) => O.OverloadedMethod TextPositionToCoordsMethodInfo a signature where
    overloadedMethod = textPositionToCoords

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


#endif

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

foreign import ccall "clutter_text_set_activatable" clutter_text_set_activatable :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- activatable : TBasicType TBoolean
    IO ()

-- | Sets whether a t'GI.Clutter.Objects.Text.Text' actor should be activatable.
-- 
-- An activatable t'GI.Clutter.Objects.Text.Text' actor will emit the [activate]("GI.Clutter.Objects.Text#g:signal:activate")
-- signal whenever the \'Enter\' (or \'Return\') key is pressed; if it is not
-- activatable, a new line will be appended to the current content.
-- 
-- An activatable t'GI.Clutter.Objects.Text.Text' must also be set as editable using
-- 'GI.Clutter.Objects.Text.textSetEditable'.
-- 
-- /Since: 1.0/
textSetActivatable ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Bool
    -- ^ /@activatable@/: whether the t'GI.Clutter.Objects.Text.Text' actor should be activatable
    -> m ()
textSetActivatable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Bool -> m ()
textSetActivatable a
self Bool
activatable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let activatable' :: CInt
activatable' = (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
activatable
    Ptr Text -> CInt -> IO ()
clutter_text_set_activatable Ptr Text
self' CInt
activatable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetActivatableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetActivatableMethodInfo a signature where
    overloadedMethod = textSetActivatable

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


#endif

-- method Text::set_attributes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attrs"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "AttrList" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #PangoAttrList or %NULL to unset the attributes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_attributes" clutter_text_set_attributes :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Ptr Pango.AttrList.AttrList ->          -- attrs : TInterface (Name {namespace = "Pango", name = "AttrList"})
    IO ()

-- | Sets the attributes list that are going to be applied to the
-- t'GI.Clutter.Objects.Text.Text' contents.
-- 
-- The t'GI.Clutter.Objects.Text.Text' actor will take a reference on the t'GI.Pango.Structs.AttrList.AttrList'
-- passed to this function.
-- 
-- /Since: 1.0/
textSetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Maybe (Pango.AttrList.AttrList)
    -- ^ /@attrs@/: a t'GI.Pango.Structs.AttrList.AttrList' or 'P.Nothing' to unset the attributes
    -> m ()
textSetAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Maybe AttrList -> m ()
textSetAttributes a
self Maybe AttrList
attrs = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AttrList
maybeAttrs <- case Maybe AttrList
attrs of
        Maybe AttrList
Nothing -> Ptr AttrList -> IO (Ptr AttrList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AttrList
forall a. Ptr a
nullPtr
        Just AttrList
jAttrs -> do
            Ptr AttrList
jAttrs' <- AttrList -> IO (Ptr AttrList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AttrList
jAttrs
            Ptr AttrList -> IO (Ptr AttrList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AttrList
jAttrs'
    Ptr Text -> Ptr AttrList -> IO ()
clutter_text_set_attributes Ptr Text
self' Ptr AttrList
maybeAttrs
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe AttrList -> (AttrList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe AttrList
attrs AttrList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetAttributesMethodInfo
instance (signature ~ (Maybe (Pango.AttrList.AttrList) -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetAttributesMethodInfo a signature where
    overloadedMethod = textSetAttributes

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


#endif

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

foreign import ccall "clutter_text_set_buffer" clutter_text_set_buffer :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Ptr Clutter.TextBuffer.TextBuffer ->    -- buffer : TInterface (Name {namespace = "Clutter", name = "TextBuffer"})
    IO ()

-- | Set the t'GI.Clutter.Objects.TextBuffer.TextBuffer' object which holds the text for
-- this widget.
-- 
-- /Since: 1.10/
textSetBuffer ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a, Clutter.TextBuffer.IsTextBuffer b) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> b
    -- ^ /@buffer@/: a t'GI.Clutter.Objects.TextBuffer.TextBuffer'
    -> m ()
textSetBuffer :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsText a, IsTextBuffer b) =>
a -> b -> m ()
textSetBuffer a
self b
buffer = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TextBuffer
buffer' <- b -> IO (Ptr TextBuffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
buffer
    Ptr Text -> Ptr TextBuffer -> IO ()
clutter_text_set_buffer Ptr Text
self' Ptr TextBuffer
buffer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
buffer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetBufferMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsText a, Clutter.TextBuffer.IsTextBuffer b) => O.OverloadedMethod TextSetBufferMethodInfo a signature where
    overloadedMethod = textSetBuffer

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


#endif

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

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

-- | Sets the color of the contents of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- The overall opacity of the t'GI.Clutter.Objects.Text.Text' actor will be the
-- result of the alpha value of /@color@/ and the composited
-- opacity of the actor itself on the scenegraph, as returned
-- by 'GI.Clutter.Objects.Actor.actorGetPaintOpacity'.
-- 
-- /Since: 1.0/
textSetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Clutter.Color.Color
    -- ^ /@color@/: a t'GI.Clutter.Structs.Color.Color'
    -> m ()
textSetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Color -> m ()
textSetColor a
self Color
color = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
    Ptr Text -> Ptr Color -> IO ()
clutter_text_set_color Ptr Text
self' Ptr Color
color'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Text::set_cursor_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the color of the cursor, or %NULL to unset it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the color of the cursor of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- If /@color@/ is 'P.Nothing', the cursor color will be the same as the
-- text color.
-- 
-- /Since: 1.0/
textSetCursorColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Maybe (Clutter.Color.Color)
    -- ^ /@color@/: the color of the cursor, or 'P.Nothing' to unset it
    -> m ()
textSetCursorColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Maybe Color -> m ()
textSetCursorColor a
self Maybe Color
color = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
maybeColor <- case Maybe Color
color of
        Maybe Color
Nothing -> Ptr Color -> IO (Ptr Color)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Color
forall a. Ptr a
nullPtr
        Just Color
jColor -> do
            Ptr Color
jColor' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
jColor
            Ptr Color -> IO (Ptr Color)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Color
jColor'
    Ptr Text -> Ptr Color -> IO ()
clutter_text_set_cursor_color Ptr Text
self' Ptr Color
maybeColor
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Color -> (Color -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Color
color Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetCursorColorMethodInfo
instance (signature ~ (Maybe (Clutter.Color.Color) -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetCursorColorMethodInfo a signature where
    overloadedMethod = textSetCursorColor

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


#endif

-- method Text::set_cursor_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new cursor position, in characters"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_cursor_position" clutter_text_set_cursor_position :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Int32 ->                                -- position : TBasicType TInt
    IO ()

-- | Sets the cursor of a t'GI.Clutter.Objects.Text.Text' actor at /@position@/.
-- 
-- The position is expressed in characters, not in bytes.
-- 
-- /Since: 1.0/
textSetCursorPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Int32
    -- ^ /@position@/: the new cursor position, in characters
    -> m ()
textSetCursorPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m ()
textSetCursorPosition a
self Int32
position = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Text -> Int32 -> IO ()
clutter_text_set_cursor_position Ptr Text
self' Int32
position
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetCursorPositionMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetCursorPositionMethodInfo a signature where
    overloadedMethod = textSetCursorPosition

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


#endif

-- method Text::set_cursor_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the size of the cursor, in pixels, or -1 to use the\n  default 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_text_set_cursor_size" clutter_text_set_cursor_size :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Int32 ->                                -- size : TBasicType TInt
    IO ()

-- | Sets the size of the cursor of a t'GI.Clutter.Objects.Text.Text'. The cursor
-- will only be visible if the t'GI.Clutter.Objects.Text.Text':@/cursor-visible/@ property
-- is set to 'P.True'.
-- 
-- /Since: 1.0/
textSetCursorSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Int32
    -- ^ /@size@/: the size of the cursor, in pixels, or -1 to use the
    --   default value
    -> m ()
textSetCursorSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m ()
textSetCursorSize a
self Int32
size = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Text -> Int32 -> IO ()
clutter_text_set_cursor_size Ptr Text
self' Int32
size
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetCursorSizeMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetCursorSizeMethodInfo a signature where
    overloadedMethod = textSetCursorSize

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


#endif

-- method Text::set_cursor_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the cursor should be visible"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_cursor_visible" clutter_text_set_cursor_visible :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- cursor_visible : TBasicType TBoolean
    IO ()

-- | Sets whether the cursor of a t'GI.Clutter.Objects.Text.Text' actor should be
-- visible or not.
-- 
-- The color of the cursor will be the same as the text color
-- unless 'GI.Clutter.Objects.Text.textSetCursorColor' has been called.
-- 
-- The size of the cursor can be set using 'GI.Clutter.Objects.Text.textSetCursorSize'.
-- 
-- The position of the cursor can be changed programmatically using
-- 'GI.Clutter.Objects.Text.textSetCursorPosition'.
-- 
-- /Since: 1.0/
textSetCursorVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Bool
    -- ^ /@cursorVisible@/: whether the cursor should be visible
    -> m ()
textSetCursorVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Bool -> m ()
textSetCursorVisible a
self Bool
cursorVisible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let cursorVisible' :: CInt
cursorVisible' = (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
cursorVisible
    Ptr Text -> CInt -> IO ()
clutter_text_set_cursor_visible Ptr Text
self' CInt
cursorVisible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetCursorVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetCursorVisibleMethodInfo a signature where
    overloadedMethod = textSetCursorVisible

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


#endif

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

foreign import ccall "clutter_text_set_editable" clutter_text_set_editable :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- editable : TBasicType TBoolean
    IO ()

-- | Sets whether the t'GI.Clutter.Objects.Text.Text' actor should be editable.
-- 
-- An editable t'GI.Clutter.Objects.Text.Text' with key focus set using
-- 'GI.Clutter.Objects.Actor.actorGrabKeyFocus' or 'GI.Clutter.Objects.Stage.stageSetKeyFocus'
-- will receive key events and will update its contents accordingly.
-- 
-- /Since: 1.0/
textSetEditable ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Bool
    -- ^ /@editable@/: whether the t'GI.Clutter.Objects.Text.Text' should be editable
    -> m ()
textSetEditable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Bool -> m ()
textSetEditable a
self Bool
editable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let editable' :: CInt
editable' = (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
editable
    Ptr Text -> CInt -> IO ()
clutter_text_set_editable Ptr Text
self' CInt
editable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetEditableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetEditableMethodInfo a signature where
    overloadedMethod = textSetEditable

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


#endif

-- method Text::set_ellipsize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "EllipsizeMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PangoEllipsizeMode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_ellipsize" clutter_text_set_ellipsize :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Pango", name = "EllipsizeMode"})
    IO ()

-- | Sets the mode used to ellipsize (add an ellipsis: \"...\") to the
-- text if there is not enough space to render the entire contents
-- of a t'GI.Clutter.Objects.Text.Text' actor
-- 
-- /Since: 1.0/
textSetEllipsize ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Pango.Enums.EllipsizeMode
    -- ^ /@mode@/: a t'GI.Pango.Enums.EllipsizeMode'
    -> m ()
textSetEllipsize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> EllipsizeMode -> m ()
textSetEllipsize a
self EllipsizeMode
mode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EllipsizeMode -> Int) -> EllipsizeMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EllipsizeMode -> Int
forall a. Enum a => a -> Int
fromEnum) EllipsizeMode
mode
    Ptr Text -> CUInt -> IO ()
clutter_text_set_ellipsize Ptr Text
self' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetEllipsizeMethodInfo
instance (signature ~ (Pango.Enums.EllipsizeMode -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetEllipsizeMethodInfo a signature where
    overloadedMethod = textSetEllipsize

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


#endif

-- method Text::set_font_description
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_desc"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "FontDescription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PangoFontDescription"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_font_description" clutter_text_set_font_description :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Ptr Pango.FontDescription.FontDescription -> -- font_desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
    IO ()

-- | Sets /@fontDesc@/ as the font description for a t'GI.Clutter.Objects.Text.Text'
-- 
-- The t'GI.Pango.Structs.FontDescription.FontDescription' is copied by the t'GI.Clutter.Objects.Text.Text' actor
-- so you can safely call 'GI.Pango.Structs.FontDescription.fontDescriptionFree' on it after
-- calling this function.
-- 
-- /Since: 1.2/
textSetFontDescription ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Pango.FontDescription.FontDescription
    -- ^ /@fontDesc@/: a t'GI.Pango.Structs.FontDescription.FontDescription'
    -> m ()
textSetFontDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> FontDescription -> m ()
textSetFontDescription a
self FontDescription
fontDesc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr FontDescription
fontDesc' <- FontDescription -> IO (Ptr FontDescription)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FontDescription
fontDesc
    Ptr Text -> Ptr FontDescription -> IO ()
clutter_text_set_font_description Ptr Text
self' Ptr FontDescription
fontDesc'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    FontDescription -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr FontDescription
fontDesc
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetFontDescriptionMethodInfo
instance (signature ~ (Pango.FontDescription.FontDescription -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetFontDescriptionMethodInfo a signature where
    overloadedMethod = textSetFontDescription

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


#endif

-- method Text::set_font_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a font name, or %NULL to set the default font name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_font_name" clutter_text_set_font_name :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CString ->                              -- font_name : TBasicType TUTF8
    IO ()

-- | Sets the font used by a t'GI.Clutter.Objects.Text.Text'. The /@fontName@/ string
-- must either be 'P.Nothing', which means that the font name from the
-- default t'GI.Clutter.Objects.Backend.Backend' will be used; or be something that can
-- be parsed by the 'GI.Pango.Functions.fontDescriptionFromString' function,
-- like:
-- 
-- >
-- >  // Set the font to the system's Sans, 10 points
-- >  clutter_text_set_font_name (text, "Sans 10");
-- >
-- >  // Set the font to the system's Serif, 16 pixels
-- >  clutter_text_set_font_name (text, "Serif 16px");
-- >
-- >  // Set the font to Helvetica, 10 points
-- >  clutter_text_set_font_name (text, "Helvetica 10");
-- 
-- 
-- /Since: 1.0/
textSetFontName ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Maybe (T.Text)
    -- ^ /@fontName@/: a font name, or 'P.Nothing' to set the default font name
    -> m ()
textSetFontName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Maybe Text -> m ()
textSetFontName a
self Maybe Text
fontName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeFontName <- case Maybe Text
fontName of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFontName -> do
            CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontName'
    Ptr Text -> CString -> IO ()
clutter_text_set_font_name Ptr Text
self' CString
maybeFontName
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontName
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetFontNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetFontNameMethodInfo a signature where
    overloadedMethod = textSetFontName

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


#endif

-- method Text::set_justify
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "justify"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the text should be justified"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_justify" clutter_text_set_justify :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- justify : TBasicType TBoolean
    IO ()

-- | Sets whether the text of the t'GI.Clutter.Objects.Text.Text' actor should be justified
-- on both margins. This setting is ignored if Clutter is compiled
-- against Pango &lt; 1.18.
-- 
-- /Since: 1.0/
textSetJustify ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Bool
    -- ^ /@justify@/: whether the text should be justified
    -> m ()
textSetJustify :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Bool -> m ()
textSetJustify a
self Bool
justify = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let justify' :: CInt
justify' = (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
justify
    Ptr Text -> CInt -> IO ()
clutter_text_set_justify Ptr Text
self' CInt
justify'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetJustifyMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetJustifyMethodInfo a signature where
    overloadedMethod = textSetJustify

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


#endif

-- method Text::set_line_alignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "alignment"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Alignment" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #PangoAlignment" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_line_alignment" clutter_text_set_line_alignment :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CUInt ->                                -- alignment : TInterface (Name {namespace = "Pango", name = "Alignment"})
    IO ()

-- | Sets the way that the lines of a wrapped label are aligned with
-- respect to each other. This does not affect the overall alignment
-- of the label within its allocated or specified width.
-- 
-- To align a t'GI.Clutter.Objects.Text.Text' actor you should add it to a container
-- that supports alignment, or use the anchor point.
-- 
-- /Since: 1.0/
textSetLineAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Pango.Enums.Alignment
    -- ^ /@alignment@/: A t'GI.Pango.Enums.Alignment'
    -> m ()
textSetLineAlignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Alignment -> m ()
textSetLineAlignment a
self Alignment
alignment = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let alignment' :: CUInt
alignment' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Alignment -> Int) -> Alignment -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alignment -> Int
forall a. Enum a => a -> Int
fromEnum) Alignment
alignment
    Ptr Text -> CUInt -> IO ()
clutter_text_set_line_alignment Ptr Text
self' CUInt
alignment'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetLineAlignmentMethodInfo
instance (signature ~ (Pango.Enums.Alignment -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetLineAlignmentMethodInfo a signature where
    overloadedMethod = textSetLineAlignment

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


#endif

-- method Text::set_line_wrap
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "line_wrap"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the contents should wrap"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_line_wrap" clutter_text_set_line_wrap :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- line_wrap : TBasicType TBoolean
    IO ()

-- | Sets whether the contents of a t'GI.Clutter.Objects.Text.Text' actor should wrap,
-- if they don\'t fit the size assigned to the actor.
-- 
-- /Since: 1.0/
textSetLineWrap ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Bool
    -- ^ /@lineWrap@/: whether the contents should wrap
    -> m ()
textSetLineWrap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Bool -> m ()
textSetLineWrap a
self Bool
lineWrap = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let lineWrap' :: CInt
lineWrap' = (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
lineWrap
    Ptr Text -> CInt -> IO ()
clutter_text_set_line_wrap Ptr Text
self' CInt
lineWrap'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetLineWrapMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetLineWrapMethodInfo a signature where
    overloadedMethod = textSetLineWrap

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


#endif

-- method Text::set_line_wrap_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wrap_mode"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "WrapMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the line wrapping mode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_line_wrap_mode" clutter_text_set_line_wrap_mode :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CUInt ->                                -- wrap_mode : TInterface (Name {namespace = "Pango", name = "WrapMode"})
    IO ()

-- | If line wrapping is enabled (see 'GI.Clutter.Objects.Text.textSetLineWrap') this
-- function controls how the line wrapping is performed. The default is
-- 'GI.Pango.Enums.WrapModeWord' which means wrap on word boundaries.
-- 
-- /Since: 1.0/
textSetLineWrapMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Pango.Enums.WrapMode
    -- ^ /@wrapMode@/: the line wrapping mode
    -> m ()
textSetLineWrapMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> WrapMode -> m ()
textSetLineWrapMode a
self WrapMode
wrapMode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let wrapMode' :: CUInt
wrapMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (WrapMode -> Int) -> WrapMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapMode -> Int
forall a. Enum a => a -> Int
fromEnum) WrapMode
wrapMode
    Ptr Text -> CUInt -> IO ()
clutter_text_set_line_wrap_mode Ptr Text
self' CUInt
wrapMode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetLineWrapModeMethodInfo
instance (signature ~ (Pango.Enums.WrapMode -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetLineWrapModeMethodInfo a signature where
    overloadedMethod = textSetLineWrapMode

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


#endif

-- method Text::set_markup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "markup"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a string containing Pango markup.\n  Passing %NULL is the same as passing \"\" (the empty string)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_markup" clutter_text_set_markup :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CString ->                              -- markup : TBasicType TUTF8
    IO ()

-- | Sets /@markup@/ as the contents of a t'GI.Clutter.Objects.Text.Text'.
-- 
-- This is a convenience function for setting a string containing
-- Pango markup, and it is logically equivalent to:
-- 
-- >
-- >  /&ast; the order is important &ast;/
-- >  clutter_text_set_text (CLUTTER_TEXT (actor), markup);
-- >  clutter_text_set_use_markup (CLUTTER_TEXT (actor), TRUE);
-- 
-- 
-- /Since: 1.0/
textSetMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Maybe (T.Text)
    -- ^ /@markup@/: a string containing Pango markup.
    --   Passing 'P.Nothing' is the same as passing \"\" (the empty string)
    -> m ()
textSetMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Maybe Text -> m ()
textSetMarkup a
self Maybe Text
markup = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeMarkup <- case Maybe Text
markup of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jMarkup -> do
            CString
jMarkup' <- Text -> IO CString
textToCString Text
jMarkup
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jMarkup'
    Ptr Text -> CString -> IO ()
clutter_text_set_markup Ptr Text
self' CString
maybeMarkup
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeMarkup
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetMarkupMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetMarkupMethodInfo a signature where
    overloadedMethod = textSetMarkup

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


#endif

-- method Text::set_max_length
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the maximum number of characters allowed in the text actor; 0\n  to disable or -1 to set the length of the current string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_max_length" clutter_text_set_max_length :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Int32 ->                                -- max : TBasicType TInt
    IO ()

-- | Sets the maximum allowed length of the contents of the actor. If the
-- current contents are longer than the given length, then they will be
-- truncated to fit.
-- 
-- /Since: 1.0/
textSetMaxLength ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Int32
    -- ^ /@max@/: the maximum number of characters allowed in the text actor; 0
    --   to disable or -1 to set the length of the current string
    -> m ()
textSetMaxLength :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m ()
textSetMaxLength a
self Int32
max = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Text -> Int32 -> IO ()
clutter_text_set_max_length Ptr Text
self' Int32
max
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetMaxLengthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetMaxLengthMethodInfo a signature where
    overloadedMethod = textSetMaxLength

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


#endif

-- method Text::set_password_char
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wc"
--           , argType = TBasicType TUniChar
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a Unicode character, or 0 to unset the password character"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_password_char" clutter_text_set_password_char :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- wc : TBasicType TUniChar
    IO ()

-- | Sets the character to use in place of the actual text in a
-- password text actor.
-- 
-- If /@wc@/ is 0 the text will be displayed as it is entered in the
-- t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- /Since: 1.0/
textSetPasswordChar ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Char
    -- ^ /@wc@/: a Unicode character, or 0 to unset the password character
    -> m ()
textSetPasswordChar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Char -> m ()
textSetPasswordChar a
self Char
wc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let wc' :: CInt
wc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord) Char
wc
    Ptr Text -> CInt -> IO ()
clutter_text_set_password_char Ptr Text
self' CInt
wc'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetPasswordCharMethodInfo
instance (signature ~ (Char -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetPasswordCharMethodInfo a signature where
    overloadedMethod = textSetPasswordChar

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


#endif

-- method Text::set_preedit_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "preedit_str"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pre-edit string, or %NULL to unset it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "preedit_attrs"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "AttrList" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pre-edit string attributes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_pos"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the cursor position for the pre-edit string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_preedit_string" clutter_text_set_preedit_string :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CString ->                              -- preedit_str : TBasicType TUTF8
    Ptr Pango.AttrList.AttrList ->          -- preedit_attrs : TInterface (Name {namespace = "Pango", name = "AttrList"})
    Word32 ->                               -- cursor_pos : TBasicType TUInt
    IO ()

-- | Sets, or unsets, the pre-edit string. This function is useful
-- for input methods to display a string (with eventual specific
-- Pango attributes) before it is entered inside the t'GI.Clutter.Objects.Text.Text'
-- buffer.
-- 
-- The preedit string and attributes are ignored if the t'GI.Clutter.Objects.Text.Text'
-- actor is not editable.
-- 
-- This function should not be used by applications
-- 
-- /Since: 1.2/
textSetPreeditString ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Maybe (T.Text)
    -- ^ /@preeditStr@/: the pre-edit string, or 'P.Nothing' to unset it
    -> Maybe (Pango.AttrList.AttrList)
    -- ^ /@preeditAttrs@/: the pre-edit string attributes
    -> Word32
    -- ^ /@cursorPos@/: the cursor position for the pre-edit string
    -> m ()
textSetPreeditString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Maybe Text -> Maybe AttrList -> Word32 -> m ()
textSetPreeditString a
self Maybe Text
preeditStr Maybe AttrList
preeditAttrs Word32
cursorPos = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybePreeditStr <- case Maybe Text
preeditStr of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jPreeditStr -> do
            CString
jPreeditStr' <- Text -> IO CString
textToCString Text
jPreeditStr
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jPreeditStr'
    Ptr AttrList
maybePreeditAttrs <- case Maybe AttrList
preeditAttrs of
        Maybe AttrList
Nothing -> Ptr AttrList -> IO (Ptr AttrList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AttrList
forall a. Ptr a
nullPtr
        Just AttrList
jPreeditAttrs -> do
            Ptr AttrList
jPreeditAttrs' <- AttrList -> IO (Ptr AttrList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AttrList
jPreeditAttrs
            Ptr AttrList -> IO (Ptr AttrList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AttrList
jPreeditAttrs'
    Ptr Text -> CString -> Ptr AttrList -> Word32 -> IO ()
clutter_text_set_preedit_string Ptr Text
self' CString
maybePreeditStr Ptr AttrList
maybePreeditAttrs Word32
cursorPos
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe AttrList -> (AttrList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe AttrList
preeditAttrs AttrList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybePreeditStr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetPreeditStringMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (Pango.AttrList.AttrList) -> Word32 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetPreeditStringMethodInfo a signature where
    overloadedMethod = textSetPreeditString

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


#endif

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

foreign import ccall "clutter_text_set_selectable" clutter_text_set_selectable :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- selectable : TBasicType TBoolean
    IO ()

-- | Sets whether a t'GI.Clutter.Objects.Text.Text' actor should be selectable.
-- 
-- A selectable t'GI.Clutter.Objects.Text.Text' will allow selecting its contents using
-- the pointer or the keyboard.
-- 
-- /Since: 1.0/
textSetSelectable ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Bool
    -- ^ /@selectable@/: whether the t'GI.Clutter.Objects.Text.Text' actor should be selectable
    -> m ()
textSetSelectable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Bool -> m ()
textSetSelectable a
self Bool
selectable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let selectable' :: CInt
selectable' = (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
selectable
    Ptr Text -> CInt -> IO ()
clutter_text_set_selectable Ptr Text
self' CInt
selectable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetSelectableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetSelectableMethodInfo a signature where
    overloadedMethod = textSetSelectable

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


#endif

-- method Text::set_selected_text_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the selected text color, or %NULL to unset it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the selected text color of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- If /@color@/ is 'P.Nothing', the selected text color will be the same as the
-- selection color, which then falls back to cursor, and then text color.
-- 
-- /Since: 1.8/
textSetSelectedTextColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Maybe (Clutter.Color.Color)
    -- ^ /@color@/: the selected text color, or 'P.Nothing' to unset it
    -> m ()
textSetSelectedTextColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Maybe Color -> m ()
textSetSelectedTextColor a
self Maybe Color
color = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
maybeColor <- case Maybe Color
color of
        Maybe Color
Nothing -> Ptr Color -> IO (Ptr Color)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Color
forall a. Ptr a
nullPtr
        Just Color
jColor -> do
            Ptr Color
jColor' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
jColor
            Ptr Color -> IO (Ptr Color)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Color
jColor'
    Ptr Text -> Ptr Color -> IO ()
clutter_text_set_selected_text_color Ptr Text
self' Ptr Color
maybeColor
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Color -> (Color -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Color
color Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetSelectedTextColorMethodInfo
instance (signature ~ (Maybe (Clutter.Color.Color) -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetSelectedTextColorMethodInfo a signature where
    overloadedMethod = textSetSelectedTextColor

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


#endif

-- method Text::set_selection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start_pos"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "start of the selection, in characters"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end_pos"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "end of the selection, in characters"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_selection" clutter_text_set_selection :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Int64 ->                                -- start_pos : TBasicType TInt64
    Int64 ->                                -- end_pos : TBasicType TInt64
    IO ()

-- | Selects the region of text between /@startPos@/ and /@endPos@/.
-- 
-- This function changes the position of the cursor to match
-- /@startPos@/ and the selection bound to match /@endPos@/.
-- 
-- /Since: 1.0/
textSetSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Int64
    -- ^ /@startPos@/: start of the selection, in characters
    -> Int64
    -- ^ /@endPos@/: end of the selection, in characters
    -> m ()
textSetSelection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int64 -> Int64 -> m ()
textSetSelection a
self Int64
startPos Int64
endPos = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Text -> Int64 -> Int64 -> IO ()
clutter_text_set_selection Ptr Text
self' Int64
startPos Int64
endPos
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetSelectionMethodInfo
instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetSelectionMethodInfo a signature where
    overloadedMethod = textSetSelection

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


#endif

-- method Text::set_selection_bound
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "selection_bound"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the position of the end of the selection, in characters"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_selection_bound" clutter_text_set_selection_bound :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    Int32 ->                                -- selection_bound : TBasicType TInt
    IO ()

-- | Sets the other end of the selection, starting from the current
-- cursor position.
-- 
-- If /@selectionBound@/ is -1, the selection unset.
-- 
-- /Since: 1.0/
textSetSelectionBound ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Int32
    -- ^ /@selectionBound@/: the position of the end of the selection, in characters
    -> m ()
textSetSelectionBound :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Int32 -> m ()
textSetSelectionBound a
self Int32
selectionBound = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Text -> Int32 -> IO ()
clutter_text_set_selection_bound Ptr Text
self' Int32
selectionBound
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetSelectionBoundMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetSelectionBoundMethodInfo a signature where
    overloadedMethod = textSetSelectionBound

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


#endif

-- method Text::set_selection_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Color" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the color of the selection, or %NULL to unset it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the color of the selection of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- If /@color@/ is 'P.Nothing', the selection color will be the same as the
-- cursor color, or if no cursor color is set either then it will be
-- the same as the text color.
-- 
-- /Since: 1.0/
textSetSelectionColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Maybe (Clutter.Color.Color)
    -- ^ /@color@/: the color of the selection, or 'P.Nothing' to unset it
    -> m ()
textSetSelectionColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Maybe Color -> m ()
textSetSelectionColor a
self Maybe Color
color = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Color
maybeColor <- case Maybe Color
color of
        Maybe Color
Nothing -> Ptr Color -> IO (Ptr Color)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Color
forall a. Ptr a
nullPtr
        Just Color
jColor -> do
            Ptr Color
jColor' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
jColor
            Ptr Color -> IO (Ptr Color)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Color
jColor'
    Ptr Text -> Ptr Color -> IO ()
clutter_text_set_selection_color Ptr Text
self' Ptr Color
maybeColor
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Color -> (Color -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Color
color Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetSelectionColorMethodInfo
instance (signature ~ (Maybe (Clutter.Color.Color) -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetSelectionColorMethodInfo a signature where
    overloadedMethod = textSetSelectionColor

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


#endif

-- method Text::set_single_line_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "single_line"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to enable single line mode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_single_line_mode" clutter_text_set_single_line_mode :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- single_line : TBasicType TBoolean
    IO ()

-- | Sets whether a t'GI.Clutter.Objects.Text.Text' actor should be in single line mode
-- or not. Only editable t'GI.Clutter.Objects.Text.Text's can be in single line
-- mode.
-- 
-- A text actor in single line mode will not wrap text and will clip
-- the visible area to the predefined size. The contents of the
-- text actor will scroll to display the end of the text if its length
-- is bigger than the allocated width.
-- 
-- When setting the single line mode the t'GI.Clutter.Objects.Text.Text':@/activatable/@
-- property is also set as a side effect. Instead of entering a new
-- line character, the text actor will emit the [activate]("GI.Clutter.Objects.Text#g:signal:activate")
-- signal.
-- 
-- /Since: 1.0/
textSetSingleLineMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Bool
    -- ^ /@singleLine@/: whether to enable single line mode
    -> m ()
textSetSingleLineMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Bool -> m ()
textSetSingleLineMode a
self Bool
singleLine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let singleLine' :: CInt
singleLine' = (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
singleLine
    Ptr Text -> CInt -> IO ()
clutter_text_set_single_line_mode Ptr Text
self' CInt
singleLine'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetSingleLineModeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetSingleLineModeMethodInfo a signature where
    overloadedMethod = textSetSingleLineMode

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


#endif

-- method Text::set_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the text to set. Passing %NULL is the same\n  as passing \"\" (the empty string)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_text" clutter_text_set_text :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CString ->                              -- text : TBasicType TUTF8
    IO ()

-- | Sets the contents of a t'GI.Clutter.Objects.Text.Text' actor.
-- 
-- If the t'GI.Clutter.Objects.Text.Text':@/use-markup/@ property was set to 'P.True' it
-- will be reset to 'P.False' as a side effect. If you want to
-- maintain the t'GI.Clutter.Objects.Text.Text':@/use-markup/@ you should use the
-- 'GI.Clutter.Objects.Text.textSetMarkup' function instead
-- 
-- /Since: 1.0/
textSetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Maybe (T.Text)
    -- ^ /@text@/: the text to set. Passing 'P.Nothing' is the same
    --   as passing \"\" (the empty string)
    -> m ()
textSetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Maybe Text -> m ()
textSetText a
self Maybe Text
text = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeText <- case Maybe Text
text of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jText -> do
            CString
jText' <- Text -> IO CString
textToCString Text
jText
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jText'
    Ptr Text -> CString -> IO ()
clutter_text_set_text Ptr Text
self' CString
maybeText
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeText
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetTextMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetTextMethodInfo a signature where
    overloadedMethod = textSetText

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


#endif

-- method Text::set_use_markup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterText" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "setting"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if the text should be parsed for markup."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_text_set_use_markup" clutter_text_set_use_markup :: 
    Ptr Text ->                             -- self : TInterface (Name {namespace = "Clutter", name = "Text"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

-- | Sets whether the contents of the t'GI.Clutter.Objects.Text.Text' actor contains markup
-- in \<link linkend=\"PangoMarkupFormat\">Pango\'s text markup language\<\/link>.
-- 
-- Setting t'GI.Clutter.Objects.Text.Text':@/use-markup/@ on an editable t'GI.Clutter.Objects.Text.Text' will
-- not have any effect except hiding the markup.
-- 
-- See also t'GI.Clutter.Objects.Text.Text':@/use-markup/@.
-- 
-- /Since: 1.0/
textSetUseMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsText a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.Text.Text'
    -> Bool
    -- ^ /@setting@/: 'P.True' if the text should be parsed for markup.
    -> m ()
textSetUseMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsText a) =>
a -> Bool -> m ()
textSetUseMarkup a
self Bool
setting = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Text
self' <- a -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let setting' :: CInt
setting' = (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
setting
    Ptr Text -> CInt -> IO ()
clutter_text_set_use_markup Ptr Text
self' CInt
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextSetUseMarkupMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsText a) => O.OverloadedMethod TextSetUseMarkupMethodInfo a signature where
    overloadedMethod = textSetUseMarkup

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


#endif