    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    The 'GI.Pango.Objects.Layout.Layout' structure represents an entire paragraph
    of text. It is initialized with a 'GI.Pango.Objects.Context.Context', UTF-8 string
    and set of attributes for that string. Once that is done, the
    set of formatted lines can be extracted from the object,
    the layout can be rendered, and conversion between logical
    character positions within the layout\'s text, and the physical
    position of the resulting glyphs can be made.

    There are also a number of parameters to adjust the formatting
    of a 'GI.Pango.Objects.Layout.Layout', which are illustrated in \<xref linkend=\"parameters\"\/>.
    It is possible, as well, to ignore the 2-D setup, and simply
    treat the results of a 'GI.Pango.Objects.Layout.Layout' as a list of lines.

    \<figure id=\"parameters\">
    \<title>Adjustable parameters for a PangoLayout\<\/title>
    \<graphic fileref=\"layout.gif\" format=\"GIF\">\<\/graphic>
    \<\/figure>

    The 'GI.Pango.Objects.Layout.Layout' structure is opaque, and has no user-visible
    fields.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Pango.Objects.Layout
        (
    #if ENABLE_OVERLOADING
        LayoutSetMarkupWithAccelMethodInfo      ,
    #endif

    -- * Exported types
        Layout(..)                              ,
        IsLayout                                ,
        toLayout                                ,
        noLayout                                ,

     -- * Methods
    -- ** contextChanged #method:contextChanged#

    #if ENABLE_OVERLOADING
        LayoutContextChangedMethodInfo          ,
    #endif
        layoutContextChanged                    ,

    -- ** copy #method:copy#

    #if ENABLE_OVERLOADING
        LayoutCopyMethodInfo                    ,
    #endif
        layoutCopy                              ,

    -- ** getAlignment #method:getAlignment#

    #if ENABLE_OVERLOADING
        LayoutGetAlignmentMethodInfo            ,
    #endif
        layoutGetAlignment                      ,

    -- ** getAttributes #method:getAttributes#

    #if ENABLE_OVERLOADING
        LayoutGetAttributesMethodInfo           ,
    #endif
        layoutGetAttributes                     ,

    -- ** getAutoDir #method:getAutoDir#

    #if ENABLE_OVERLOADING
        LayoutGetAutoDirMethodInfo              ,
    #endif
        layoutGetAutoDir                        ,

    -- ** getBaseline #method:getBaseline#

    #if ENABLE_OVERLOADING
        LayoutGetBaselineMethodInfo             ,
    #endif
        layoutGetBaseline                       ,

    -- ** getCharacterCount #method:getCharacterCount#

    #if ENABLE_OVERLOADING
        LayoutGetCharacterCountMethodInfo       ,
    #endif
        layoutGetCharacterCount                 ,

    -- ** getContext #method:getContext#

    #if ENABLE_OVERLOADING
        LayoutGetContextMethodInfo              ,
    #endif
        layoutGetContext                        ,

    -- ** getCursorPos #method:getCursorPos#

    #if ENABLE_OVERLOADING
        LayoutGetCursorPosMethodInfo            ,
    #endif
        layoutGetCursorPos                      ,

    -- ** getEllipsize #method:getEllipsize#

    #if ENABLE_OVERLOADING
        LayoutGetEllipsizeMethodInfo            ,
    #endif
        layoutGetEllipsize                      ,

    -- ** getExtents #method:getExtents#

    #if ENABLE_OVERLOADING
        LayoutGetExtentsMethodInfo              ,
    #endif
        layoutGetExtents                        ,

    -- ** getFontDescription #method:getFontDescription#

    #if ENABLE_OVERLOADING
        LayoutGetFontDescriptionMethodInfo      ,
    #endif
        layoutGetFontDescription                ,

    -- ** getHeight #method:getHeight#

    #if ENABLE_OVERLOADING
        LayoutGetHeightMethodInfo               ,
    #endif
        layoutGetHeight                         ,

    -- ** getIndent #method:getIndent#

    #if ENABLE_OVERLOADING
        LayoutGetIndentMethodInfo               ,
    #endif
        layoutGetIndent                         ,

    -- ** getIter #method:getIter#

    #if ENABLE_OVERLOADING
        LayoutGetIterMethodInfo                 ,
    #endif
        layoutGetIter                           ,

    -- ** getJustify #method:getJustify#

    #if ENABLE_OVERLOADING
        LayoutGetJustifyMethodInfo              ,
    #endif
        layoutGetJustify                        ,

    -- ** getLine #method:getLine#

    #if ENABLE_OVERLOADING
        LayoutGetLineMethodInfo                 ,
    #endif
        layoutGetLine                           ,

    -- ** getLineCount #method:getLineCount#

    #if ENABLE_OVERLOADING
        LayoutGetLineCountMethodInfo            ,
    #endif
        layoutGetLineCount                      ,

    -- ** getLineReadonly #method:getLineReadonly#

    #if ENABLE_OVERLOADING
        LayoutGetLineReadonlyMethodInfo         ,
    #endif
        layoutGetLineReadonly                   ,

    -- ** getLines #method:getLines#

    #if ENABLE_OVERLOADING
        LayoutGetLinesMethodInfo                ,
    #endif
        layoutGetLines                          ,

    -- ** getLinesReadonly #method:getLinesReadonly#

    #if ENABLE_OVERLOADING
        LayoutGetLinesReadonlyMethodInfo        ,
    #endif
        layoutGetLinesReadonly                  ,

    -- ** getLogAttrs #method:getLogAttrs#

    #if ENABLE_OVERLOADING
        LayoutGetLogAttrsMethodInfo             ,
    #endif
        layoutGetLogAttrs                       ,

    -- ** getLogAttrsReadonly #method:getLogAttrsReadonly#

    #if ENABLE_OVERLOADING
        LayoutGetLogAttrsReadonlyMethodInfo     ,
    #endif
        layoutGetLogAttrsReadonly               ,

    -- ** getPixelExtents #method:getPixelExtents#

    #if ENABLE_OVERLOADING
        LayoutGetPixelExtentsMethodInfo         ,
    #endif
        layoutGetPixelExtents                   ,

    -- ** getPixelSize #method:getPixelSize#

    #if ENABLE_OVERLOADING
        LayoutGetPixelSizeMethodInfo            ,
    #endif
        layoutGetPixelSize                      ,

    -- ** getSerial #method:getSerial#

    #if ENABLE_OVERLOADING
        LayoutGetSerialMethodInfo               ,
    #endif
        layoutGetSerial                         ,

    -- ** getSingleParagraphMode #method:getSingleParagraphMode#

    #if ENABLE_OVERLOADING
        LayoutGetSingleParagraphModeMethodInfo  ,
    #endif
        layoutGetSingleParagraphMode            ,

    -- ** getSize #method:getSize#

    #if ENABLE_OVERLOADING
        LayoutGetSizeMethodInfo                 ,
    #endif
        layoutGetSize                           ,

    -- ** getSpacing #method:getSpacing#

    #if ENABLE_OVERLOADING
        LayoutGetSpacingMethodInfo              ,
    #endif
        layoutGetSpacing                        ,

    -- ** getTabs #method:getTabs#

    #if ENABLE_OVERLOADING
        LayoutGetTabsMethodInfo                 ,
    #endif
        layoutGetTabs                           ,

    -- ** getText #method:getText#

    #if ENABLE_OVERLOADING
        LayoutGetTextMethodInfo                 ,
    #endif
        layoutGetText                           ,

    -- ** getUnknownGlyphsCount #method:getUnknownGlyphsCount#

    #if ENABLE_OVERLOADING
        LayoutGetUnknownGlyphsCountMethodInfo   ,
    #endif
        layoutGetUnknownGlyphsCount             ,

    -- ** getWidth #method:getWidth#

    #if ENABLE_OVERLOADING
        LayoutGetWidthMethodInfo                ,
    #endif
        layoutGetWidth                          ,

    -- ** getWrap #method:getWrap#

    #if ENABLE_OVERLOADING
        LayoutGetWrapMethodInfo                 ,
    #endif
        layoutGetWrap                           ,

    -- ** indexToLineX #method:indexToLineX#

    #if ENABLE_OVERLOADING
        LayoutIndexToLineXMethodInfo            ,
    #endif
        layoutIndexToLineX                      ,

    -- ** indexToPos #method:indexToPos#

    #if ENABLE_OVERLOADING
        LayoutIndexToPosMethodInfo              ,
    #endif
        layoutIndexToPos                        ,

    -- ** isEllipsized #method:isEllipsized#

    #if ENABLE_OVERLOADING
        LayoutIsEllipsizedMethodInfo            ,
    #endif
        layoutIsEllipsized                      ,

    -- ** isWrapped #method:isWrapped#

    #if ENABLE_OVERLOADING
        LayoutIsWrappedMethodInfo               ,
    #endif
        layoutIsWrapped                         ,

    -- ** moveCursorVisually #method:moveCursorVisually#

    #if ENABLE_OVERLOADING
        LayoutMoveCursorVisuallyMethodInfo      ,
    #endif
        layoutMoveCursorVisually                ,

    -- ** new #method:new#

        layoutNew                               ,

    -- ** setAlignment #method:setAlignment#

    #if ENABLE_OVERLOADING
        LayoutSetAlignmentMethodInfo            ,
    #endif
        layoutSetAlignment                      ,

    -- ** setAttributes #method:setAttributes#

    #if ENABLE_OVERLOADING
        LayoutSetAttributesMethodInfo           ,
    #endif
        layoutSetAttributes                     ,

    -- ** setAutoDir #method:setAutoDir#

    #if ENABLE_OVERLOADING
        LayoutSetAutoDirMethodInfo              ,
    #endif
        layoutSetAutoDir                        ,

    -- ** setEllipsize #method:setEllipsize#

    #if ENABLE_OVERLOADING
        LayoutSetEllipsizeMethodInfo            ,
    #endif
        layoutSetEllipsize                      ,

    -- ** setFontDescription #method:setFontDescription#

    #if ENABLE_OVERLOADING
        LayoutSetFontDescriptionMethodInfo      ,
    #endif
        layoutSetFontDescription                ,

    -- ** setHeight #method:setHeight#

    #if ENABLE_OVERLOADING
        LayoutSetHeightMethodInfo               ,
    #endif
        layoutSetHeight                         ,

    -- ** setIndent #method:setIndent#

    #if ENABLE_OVERLOADING
        LayoutSetIndentMethodInfo               ,
    #endif
        layoutSetIndent                         ,

    -- ** setJustify #method:setJustify#

    #if ENABLE_OVERLOADING
        LayoutSetJustifyMethodInfo              ,
    #endif
        layoutSetJustify                        ,

    -- ** setMarkup #method:setMarkup#

    #if ENABLE_OVERLOADING
        LayoutSetMarkupMethodInfo               ,
    #endif
        layoutSetMarkup                         ,

    -- ** setSingleParagraphMode #method:setSingleParagraphMode#

    #if ENABLE_OVERLOADING
        LayoutSetSingleParagraphModeMethodInfo  ,
    #endif
        layoutSetSingleParagraphMode            ,

    -- ** setSpacing #method:setSpacing#

    #if ENABLE_OVERLOADING
        LayoutSetSpacingMethodInfo              ,
    #endif
        layoutSetSpacing                        ,

    -- ** setTabs #method:setTabs#

    #if ENABLE_OVERLOADING
        LayoutSetTabsMethodInfo                 ,
    #endif
        layoutSetTabs                           ,

    -- ** setText #method:setText#

    #if ENABLE_OVERLOADING
        LayoutSetTextMethodInfo                 ,
    #endif
        layoutSetText                           ,

    -- ** setWidth #method:setWidth#

    #if ENABLE_OVERLOADING
        LayoutSetWidthMethodInfo                ,
    #endif
        layoutSetWidth                          ,

    -- ** setWrap #method:setWrap#

    #if ENABLE_OVERLOADING
        LayoutSetWrapMethodInfo                 ,
    #endif
        layoutSetWrap                           ,

    -- ** xyToIndex #method:xyToIndex#

    #if ENABLE_OVERLOADING
        LayoutXyToIndexMethodInfo               ,
    #endif
        layoutXyToIndex                         ,

        ) 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.ManagedPtr as B.ManagedPtr
    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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums
    import {-# SOURCE #-} qualified GI.Pango.Objects.Context as Pango.Context
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrList as Pango.AttrList
    import {-# SOURCE #-} qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
    import {-# SOURCE #-} qualified GI.Pango.Structs.LayoutIter as Pango.LayoutIter
    import {-# SOURCE #-} qualified GI.Pango.Structs.LayoutLine as Pango.LayoutLine
    import {-# SOURCE #-} qualified GI.Pango.Structs.LogAttr as Pango.LogAttr
    import {-# SOURCE #-} qualified GI.Pango.Structs.Rectangle as Pango.Rectangle
    import {-# SOURCE #-} qualified GI.Pango.Structs.TabArray as Pango.TabArray

    -- | Memory-managed wrapper type.
    newtype Layout = Layout (ManagedPtr Layout)
    foreign import ccall "pango_layout_get_type"
        c_pango_layout_get_type :: IO GType

    instance GObject Layout where
        gobjectType _ = c_pango_layout_get_type

    -- | Type class for types which can be safely cast to `Layout`, for instance with `toLayout`.
    class GObject o => IsLayout o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Layout a) =>
        IsLayout a
    #endif
    instance IsLayout Layout
    instance GObject.Object.IsObject Layout

    -- | Cast to `Layout`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toLayout :: (MonadIO m, IsLayout o) => o -> m Layout
    toLayout = liftIO . unsafeCastTo Layout

    -- | A convenience alias for `Nothing` :: `Maybe` `Layout`.
    noLayout :: Maybe Layout
    noLayout = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveLayoutMethod (t :: Symbol) (o :: *) :: * where
        ResolveLayoutMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveLayoutMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveLayoutMethod "contextChanged" o = LayoutContextChangedMethodInfo
        ResolveLayoutMethod "copy" o = LayoutCopyMethodInfo
        ResolveLayoutMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveLayoutMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveLayoutMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveLayoutMethod "indexToLineX" o = LayoutIndexToLineXMethodInfo
        ResolveLayoutMethod "indexToPos" o = LayoutIndexToPosMethodInfo
        ResolveLayoutMethod "isEllipsized" o = LayoutIsEllipsizedMethodInfo
        ResolveLayoutMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveLayoutMethod "isWrapped" o = LayoutIsWrappedMethodInfo
        ResolveLayoutMethod "moveCursorVisually" o = LayoutMoveCursorVisuallyMethodInfo
        ResolveLayoutMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveLayoutMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveLayoutMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveLayoutMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveLayoutMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveLayoutMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveLayoutMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveLayoutMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveLayoutMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveLayoutMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveLayoutMethod "xyToIndex" o = LayoutXyToIndexMethodInfo
        ResolveLayoutMethod "getAlignment" o = LayoutGetAlignmentMethodInfo
        ResolveLayoutMethod "getAttributes" o = LayoutGetAttributesMethodInfo
        ResolveLayoutMethod "getAutoDir" o = LayoutGetAutoDirMethodInfo
        ResolveLayoutMethod "getBaseline" o = LayoutGetBaselineMethodInfo
        ResolveLayoutMethod "getCharacterCount" o = LayoutGetCharacterCountMethodInfo
        ResolveLayoutMethod "getContext" o = LayoutGetContextMethodInfo
        ResolveLayoutMethod "getCursorPos" o = LayoutGetCursorPosMethodInfo
        ResolveLayoutMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveLayoutMethod "getEllipsize" o = LayoutGetEllipsizeMethodInfo
        ResolveLayoutMethod "getExtents" o = LayoutGetExtentsMethodInfo
        ResolveLayoutMethod "getFontDescription" o = LayoutGetFontDescriptionMethodInfo
        ResolveLayoutMethod "getHeight" o = LayoutGetHeightMethodInfo
        ResolveLayoutMethod "getIndent" o = LayoutGetIndentMethodInfo
        ResolveLayoutMethod "getIter" o = LayoutGetIterMethodInfo
        ResolveLayoutMethod "getJustify" o = LayoutGetJustifyMethodInfo
        ResolveLayoutMethod "getLine" o = LayoutGetLineMethodInfo
        ResolveLayoutMethod "getLineCount" o = LayoutGetLineCountMethodInfo
        ResolveLayoutMethod "getLineReadonly" o = LayoutGetLineReadonlyMethodInfo
        ResolveLayoutMethod "getLines" o = LayoutGetLinesMethodInfo
        ResolveLayoutMethod "getLinesReadonly" o = LayoutGetLinesReadonlyMethodInfo
        ResolveLayoutMethod "getLogAttrs" o = LayoutGetLogAttrsMethodInfo
        ResolveLayoutMethod "getLogAttrsReadonly" o = LayoutGetLogAttrsReadonlyMethodInfo
        ResolveLayoutMethod "getPixelExtents" o = LayoutGetPixelExtentsMethodInfo
        ResolveLayoutMethod "getPixelSize" o = LayoutGetPixelSizeMethodInfo
        ResolveLayoutMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveLayoutMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveLayoutMethod "getSerial" o = LayoutGetSerialMethodInfo
        ResolveLayoutMethod "getSingleParagraphMode" o = LayoutGetSingleParagraphModeMethodInfo
        ResolveLayoutMethod "getSize" o = LayoutGetSizeMethodInfo
        ResolveLayoutMethod "getSpacing" o = LayoutGetSpacingMethodInfo
        ResolveLayoutMethod "getTabs" o = LayoutGetTabsMethodInfo
        ResolveLayoutMethod "getText" o = LayoutGetTextMethodInfo
        ResolveLayoutMethod "getUnknownGlyphsCount" o = LayoutGetUnknownGlyphsCountMethodInfo
        ResolveLayoutMethod "getWidth" o = LayoutGetWidthMethodInfo
        ResolveLayoutMethod "getWrap" o = LayoutGetWrapMethodInfo
        ResolveLayoutMethod "setAlignment" o = LayoutSetAlignmentMethodInfo
        ResolveLayoutMethod "setAttributes" o = LayoutSetAttributesMethodInfo
        ResolveLayoutMethod "setAutoDir" o = LayoutSetAutoDirMethodInfo
        ResolveLayoutMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveLayoutMethod "setEllipsize" o = LayoutSetEllipsizeMethodInfo
        ResolveLayoutMethod "setFontDescription" o = LayoutSetFontDescriptionMethodInfo
        ResolveLayoutMethod "setHeight" o = LayoutSetHeightMethodInfo
        ResolveLayoutMethod "setIndent" o = LayoutSetIndentMethodInfo
        ResolveLayoutMethod "setJustify" o = LayoutSetJustifyMethodInfo
        ResolveLayoutMethod "setMarkup" o = LayoutSetMarkupMethodInfo
        ResolveLayoutMethod "setMarkupWithAccel" o = LayoutSetMarkupWithAccelMethodInfo
        ResolveLayoutMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveLayoutMethod "setSingleParagraphMode" o = LayoutSetSingleParagraphModeMethodInfo
        ResolveLayoutMethod "setSpacing" o = LayoutSetSpacingMethodInfo
        ResolveLayoutMethod "setTabs" o = LayoutSetTabsMethodInfo
        ResolveLayoutMethod "setText" o = LayoutSetTextMethodInfo
        ResolveLayoutMethod "setWidth" o = LayoutSetWidthMethodInfo
        ResolveLayoutMethod "setWrap" o = LayoutSetWrapMethodInfo
        ResolveLayoutMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveLayoutMethod t Layout, O.MethodInfo info Layout p) => O.IsLabelProxy t (Layout -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveLayoutMethod t Layout, O.MethodInfo info Layout p) => O.IsLabel t (Layout -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Layout
    type instance O.AttributeList Layout = LayoutAttributeList
    type LayoutAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList Layout = LayoutSignalList
    type LayoutSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method Layout::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "Pango", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoContext", 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 "pango_layout_new" pango_layout_new ::
        Ptr Pango.Context.Context ->            -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO (Ptr Layout)

    {- |
    Create a new 'GI.Pango.Objects.Layout.Layout' object with attributes initialized to
    default values for a particular 'GI.Pango.Objects.Context.Context'.
    -}
    layoutNew ::
        (B.CallStack.HasCallStack, MonadIO m, Pango.Context.IsContext a) =>
        a
        {- ^ /@context@/: a 'GI.Pango.Objects.Context.Context' -}
        -> m Layout
        {- ^ __Returns:__ the newly allocated 'GI.Pango.Objects.Layout.Layout', with a reference
                  count of one, which should be freed with
                  'GI.GObject.Objects.Object.objectUnref'. -}
    layoutNew context = liftIO $ do
        context' <- unsafeManagedPtrCastPtr context
        result <- pango_layout_new context'
        checkUnexpectedReturnNULL "layoutNew" result
        result' <- (wrapObject Layout) result
        touchManagedPtr context
        return result'

    #if ENABLE_OVERLOADING
    #endif

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

    foreign import ccall "pango_layout_context_changed" pango_layout_context_changed ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO ()

    {- |
    Forces recomputation of any state in the 'GI.Pango.Objects.Layout.Layout' that
    might depend on the layout\'s context. This function should
    be called if you make changes to the context subsequent
    to creating the layout.
    -}
    layoutContextChanged ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m ()
    layoutContextChanged layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        pango_layout_context_changed layout'
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutContextChangedMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutContextChangedMethodInfo a signature where
        overloadedMethod _ = layoutContextChanged

    #endif

    -- method Layout::copy
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_copy" pango_layout_copy ::
        Ptr Layout ->                           -- src : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO (Ptr Layout)

    {- |
    Does a deep copy-by-value of the /@src@/ layout. The attribute list,
    tab array, and text from the original layout are all copied by
    value.
    -}
    layoutCopy ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@src@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Layout
        {- ^ __Returns:__ the newly allocated 'GI.Pango.Objects.Layout.Layout',
                  with a reference count of one, which should be freed
                  with 'GI.GObject.Objects.Object.objectUnref'. -}
    layoutCopy src = liftIO $ do
        src' <- unsafeManagedPtrCastPtr src
        result <- pango_layout_copy src'
        checkUnexpectedReturnNULL "layoutCopy" result
        result' <- (wrapObject Layout) result
        touchManagedPtr src
        return result'

    #if ENABLE_OVERLOADING
    data LayoutCopyMethodInfo
    instance (signature ~ (m Layout), MonadIO m, IsLayout a) => O.MethodInfo LayoutCopyMethodInfo a signature where
        overloadedMethod _ = layoutCopy

    #endif

    -- method Layout::get_alignment
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_alignment" pango_layout_get_alignment ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CUInt

    {- |
    Gets the alignment for the layout: how partial lines are
    positioned within the horizontal space available.
    -}
    layoutGetAlignment ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Pango.Enums.Alignment
        {- ^ __Returns:__ the alignment. -}
    layoutGetAlignment layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_alignment layout'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetAlignmentMethodInfo
    instance (signature ~ (m Pango.Enums.Alignment), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetAlignmentMethodInfo a signature where
        overloadedMethod _ = layoutGetAlignment

    #endif

    -- method Layout::get_attributes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_attributes" pango_layout_get_attributes ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO (Ptr Pango.AttrList.AttrList)

    {- |
    Gets the attribute list for the layout, if any.
    -}
    layoutGetAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Pango.AttrList.AttrList
        {- ^ __Returns:__ a 'GI.Pango.Structs.AttrList.AttrList'. -}
    layoutGetAttributes layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_attributes layout'
        checkUnexpectedReturnNULL "layoutGetAttributes" result
        result' <- (newBoxed Pango.AttrList.AttrList) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetAttributesMethodInfo
    instance (signature ~ (m Pango.AttrList.AttrList), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetAttributesMethodInfo a signature where
        overloadedMethod _ = layoutGetAttributes

    #endif

    -- method Layout::get_auto_dir
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_auto_dir" pango_layout_get_auto_dir ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CInt

    {- |
    Gets whether to calculate the bidirectional base direction
    for the layout according to the contents of the layout.
    See 'GI.Pango.Objects.Layout.layoutSetAutoDir'.

    /Since: 1.4/
    -}
    layoutGetAutoDir ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the bidirectional base direction
      is computed from the layout\'s contents, 'False' otherwise. -}
    layoutGetAutoDir layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_auto_dir layout'
        let result' = (/= 0) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetAutoDirMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetAutoDirMethodInfo a signature where
        overloadedMethod _ = layoutGetAutoDir

    #endif

    -- method Layout::get_baseline
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_baseline" pango_layout_get_baseline ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Int32

    {- |
    Gets the Y position of baseline of the first line in /@layout@/.

    /Since: 1.22/
    -}
    layoutGetBaseline ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Int32
        {- ^ __Returns:__ baseline of first line, from top of /@layout@/. -}
    layoutGetBaseline layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_baseline layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetBaselineMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetBaselineMethodInfo a signature where
        overloadedMethod _ = layoutGetBaseline

    #endif

    -- method Layout::get_character_count
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_character_count" pango_layout_get_character_count ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Int32

    {- |
    Returns the number of Unicode characters in the
    the text of /@layout@/.

    /Since: 1.30/
    -}
    layoutGetCharacterCount ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Int32
        {- ^ __Returns:__ the number of Unicode characters
        in the text of /@layout@/ -}
    layoutGetCharacterCount layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_character_count layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetCharacterCountMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetCharacterCountMethodInfo a signature where
        overloadedMethod _ = layoutGetCharacterCount

    #endif

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

    foreign import ccall "pango_layout_get_context" pango_layout_get_context ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO (Ptr Pango.Context.Context)

    {- |
    Retrieves the 'GI.Pango.Objects.Context.Context' used for this layout.
    -}
    layoutGetContext ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Pango.Context.Context
        {- ^ __Returns:__ the 'GI.Pango.Objects.Context.Context' for the layout.
    This does not have an additional refcount added, so if you want to
    keep a copy of this around, you must reference it yourself. -}
    layoutGetContext layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_context layout'
        checkUnexpectedReturnNULL "layoutGetContext" result
        result' <- (newObject Pango.Context.Context) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetContextMethodInfo
    instance (signature ~ (m Pango.Context.Context), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetContextMethodInfo a signature where
        overloadedMethod _ = layoutGetContext

    #endif

    -- method Layout::get_cursor_pos
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the byte index of the cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "strong_pos", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the strong cursor position\n                    (may be %NULL)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "weak_pos", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the weak cursor position (may be %NULL)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_cursor_pos" pango_layout_get_cursor_pos ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- index_ : TBasicType TInt
        Ptr Pango.Rectangle.Rectangle ->        -- strong_pos : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        Ptr Pango.Rectangle.Rectangle ->        -- weak_pos : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        IO ()

    {- |
    Given an index within a layout, determines the positions that of the
    strong and weak cursors if the insertion point is at that
    index. The position of each cursor is stored as a zero-width
    rectangle. The strong cursor location is the location where
    characters of the directionality equal to the base direction of the
    layout are inserted.  The weak cursor location is the location
    where characters of the directionality opposite to the base
    direction of the layout are inserted.
    -}
    layoutGetCursorPos ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Int32
        {- ^ /@index_@/: the byte index of the cursor -}
        -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
    layoutGetCursorPos layout index_ = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        strongPos <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        weakPos <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        pango_layout_get_cursor_pos layout' index_ strongPos weakPos
        strongPos' <- (wrapPtr Pango.Rectangle.Rectangle) strongPos
        weakPos' <- (wrapPtr Pango.Rectangle.Rectangle) weakPos
        touchManagedPtr layout
        return (strongPos', weakPos')

    #if ENABLE_OVERLOADING
    data LayoutGetCursorPosMethodInfo
    instance (signature ~ (Int32 -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetCursorPosMethodInfo a signature where
        overloadedMethod _ = layoutGetCursorPos

    #endif

    -- method Layout::get_ellipsize
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_ellipsize" pango_layout_get_ellipsize ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CUInt

    {- |
    Gets the type of ellipsization being performed for /@layout@/.
    See 'GI.Pango.Objects.Layout.layoutSetEllipsize'

    /Since: 1.6/
    -}
    layoutGetEllipsize ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Pango.Enums.EllipsizeMode
        {- ^ __Returns:__ the current ellipsization mode for /@layout@/.

    Use 'GI.Pango.Objects.Layout.layoutIsEllipsized' to query whether any paragraphs
    were actually ellipsized. -}
    layoutGetEllipsize layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_ellipsize layout'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetEllipsizeMethodInfo
    instance (signature ~ (m Pango.Enums.EllipsizeMode), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetEllipsizeMethodInfo a signature where
        overloadedMethod _ = layoutGetEllipsize

    #endif

    -- method Layout::get_extents
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ink_rect", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle used to store the extents of the\n                  layout as drawn or %NULL to indicate that the result is\n                  not needed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "logical_rect", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle used to store the logical\n                     extents of the layout or %NULL to indicate that the\n                     result is not needed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_extents" pango_layout_get_extents ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr Pango.Rectangle.Rectangle ->        -- ink_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        Ptr Pango.Rectangle.Rectangle ->        -- logical_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        IO ()

    {- |
    Computes the logical and ink extents of /@layout@/. Logical extents
    are usually what you want for positioning things.  Note that both extents
    may have non-zero x and y.  You may want to use those to offset where you
    render the layout.  Not doing that is a very typical bug that shows up as
    right-to-left layouts not being correctly positioned in a layout with
    a set width.

    The extents are given in layout coordinates and in Pango units; layout
    coordinates begin at the top left corner of the layout.
    -}
    layoutGetExtents ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
    layoutGetExtents layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        inkRect <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        logicalRect <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        pango_layout_get_extents layout' inkRect logicalRect
        inkRect' <- (wrapPtr Pango.Rectangle.Rectangle) inkRect
        logicalRect' <- (wrapPtr Pango.Rectangle.Rectangle) logicalRect
        touchManagedPtr layout
        return (inkRect', logicalRect')

    #if ENABLE_OVERLOADING
    data LayoutGetExtentsMethodInfo
    instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetExtentsMethodInfo a signature where
        overloadedMethod _ = layoutGetExtents

    #endif

    -- method Layout::get_font_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_font_description" pango_layout_get_font_description ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO (Ptr Pango.FontDescription.FontDescription)

    {- |
    Gets the font description for the layout, if any.

    /Since: 1.8/
    -}
    layoutGetFontDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m (Maybe Pango.FontDescription.FontDescription)
        {- ^ __Returns:__ a pointer to the layout\'s font
     description, or 'Nothing' if the font description from the layout\'s
     context is inherited. This value is owned by the layout and must
     not be modified or freed. -}
    layoutGetFontDescription layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_font_description layout'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed Pango.FontDescription.FontDescription) result'
            return result''
        touchManagedPtr layout
        return maybeResult

    #if ENABLE_OVERLOADING
    data LayoutGetFontDescriptionMethodInfo
    instance (signature ~ (m (Maybe Pango.FontDescription.FontDescription)), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetFontDescriptionMethodInfo a signature where
        overloadedMethod _ = layoutGetFontDescription

    #endif

    -- method Layout::get_height
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_height" pango_layout_get_height ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Int32

    {- |
    Gets the height of layout used for ellipsization.  See
    'GI.Pango.Objects.Layout.layoutSetHeight' for details.

    /Since: 1.20/
    -}
    layoutGetHeight ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Int32
        {- ^ __Returns:__ the height, in Pango units if positive, or
    number of lines if negative. -}
    layoutGetHeight layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_height layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetHeightMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetHeightMethodInfo a signature where
        overloadedMethod _ = layoutGetHeight

    #endif

    -- method Layout::get_indent
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_indent" pango_layout_get_indent ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Int32

    {- |
    Gets the paragraph indent width in Pango units. A negative value
    indicates a hanging indentation.
    -}
    layoutGetIndent ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Int32
        {- ^ __Returns:__ the indent in Pango units. -}
    layoutGetIndent layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_indent layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetIndentMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetIndentMethodInfo a signature where
        overloadedMethod _ = layoutGetIndent

    #endif

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

    foreign import ccall "pango_layout_get_iter" pango_layout_get_iter ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO (Ptr Pango.LayoutIter.LayoutIter)

    {- |
    Returns an iterator to iterate over the visual extents of the layout.
    -}
    layoutGetIter ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Pango.LayoutIter.LayoutIter
        {- ^ __Returns:__ the new 'GI.Pango.Structs.LayoutIter.LayoutIter' that should be freed using
                  'GI.Pango.Structs.LayoutIter.layoutIterFree'. -}
    layoutGetIter layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_iter layout'
        checkUnexpectedReturnNULL "layoutGetIter" result
        result' <- (wrapBoxed Pango.LayoutIter.LayoutIter) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetIterMethodInfo
    instance (signature ~ (m Pango.LayoutIter.LayoutIter), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetIterMethodInfo a signature where
        overloadedMethod _ = layoutGetIter

    #endif

    -- method Layout::get_justify
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_justify" pango_layout_get_justify ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CInt

    {- |
    Gets whether each complete line should be stretched to fill the entire
    width of the layout.
    -}
    layoutGetJustify ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Bool
        {- ^ __Returns:__ the justify. -}
    layoutGetJustify layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_justify layout'
        let result' = (/= 0) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetJustifyMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetJustifyMethodInfo a signature where
        overloadedMethod _ = layoutGetJustify

    #endif

    -- method Layout::get_line
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of a line, which must be between 0 and\n       <literal>pango_layout_get_line_count(layout) - 1</literal>, inclusive.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Pango", name = "LayoutLine"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_line" pango_layout_get_line ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- line : TBasicType TInt
        IO (Ptr Pango.LayoutLine.LayoutLine)

    {- |
    Retrieves a particular line from a 'GI.Pango.Objects.Layout.Layout'.

    Use the faster 'GI.Pango.Objects.Layout.layoutGetLineReadonly' if you do not plan
    to modify the contents of the line (glyphs, glyph widths, etc.).
    -}
    layoutGetLine ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Int32
        {- ^ /@line@/: the index of a line, which must be between 0 and
           \<literal>pango_layout_get_line_count(layout) - 1\<\/literal>, inclusive. -}
        -> m (Maybe Pango.LayoutLine.LayoutLine)
        {- ^ __Returns:__ the requested
                  'GI.Pango.Structs.LayoutLine.LayoutLine', or 'Nothing' if the index is out of
                  range. This layout line can be ref\'ed and retained,
                  but will become invalid if changes are made to the
                  'GI.Pango.Objects.Layout.Layout'. -}
    layoutGetLine layout line = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_line layout' line
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed Pango.LayoutLine.LayoutLine) result'
            return result''
        touchManagedPtr layout
        return maybeResult

    #if ENABLE_OVERLOADING
    data LayoutGetLineMethodInfo
    instance (signature ~ (Int32 -> m (Maybe Pango.LayoutLine.LayoutLine)), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetLineMethodInfo a signature where
        overloadedMethod _ = layoutGetLine

    #endif

    -- method Layout::get_line_count
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#PangoLayout", 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 "pango_layout_get_line_count" pango_layout_get_line_count ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Int32

    {- |
    Retrieves the count of lines for the /@layout@/.
    -}
    layoutGetLineCount ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: 'GI.Pango.Objects.Layout.Layout' -}
        -> m Int32
        {- ^ __Returns:__ the line count. -}
    layoutGetLineCount layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_line_count layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetLineCountMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetLineCountMethodInfo a signature where
        overloadedMethod _ = layoutGetLineCount

    #endif

    -- method Layout::get_line_readonly
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of a line, which must be between 0 and\n       <literal>pango_layout_get_line_count(layout) - 1</literal>, inclusive.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Pango", name = "LayoutLine"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_line_readonly" pango_layout_get_line_readonly ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- line : TBasicType TInt
        IO (Ptr Pango.LayoutLine.LayoutLine)

    {- |
    Retrieves a particular line from a 'GI.Pango.Objects.Layout.Layout'.

    This is a faster alternative to 'GI.Pango.Objects.Layout.layoutGetLine',
    but the user is not expected
    to modify the contents of the line (glyphs, glyph widths, etc.).

    /Since: 1.16/
    -}
    layoutGetLineReadonly ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Int32
        {- ^ /@line@/: the index of a line, which must be between 0 and
           \<literal>pango_layout_get_line_count(layout) - 1\<\/literal>, inclusive. -}
        -> m (Maybe Pango.LayoutLine.LayoutLine)
        {- ^ __Returns:__ the requested
                  'GI.Pango.Structs.LayoutLine.LayoutLine', or 'Nothing' if the index is out of
                  range. This layout line can be ref\'ed and retained,
                  but will become invalid if changes are made to the
                  'GI.Pango.Objects.Layout.Layout'.  No changes should be made to the line. -}
    layoutGetLineReadonly layout line = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_line_readonly layout' line
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed Pango.LayoutLine.LayoutLine) result'
            return result''
        touchManagedPtr layout
        return maybeResult

    #if ENABLE_OVERLOADING
    data LayoutGetLineReadonlyMethodInfo
    instance (signature ~ (Int32 -> m (Maybe Pango.LayoutLine.LayoutLine)), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetLineReadonlyMethodInfo a signature where
        overloadedMethod _ = layoutGetLineReadonly

    #endif

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

    foreign import ccall "pango_layout_get_lines" pango_layout_get_lines ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO (Ptr (GSList (Ptr Pango.LayoutLine.LayoutLine)))

    {- |
    Returns the lines of the /@layout@/ as a list.

    Use the faster 'GI.Pango.Objects.Layout.layoutGetLinesReadonly' if you do not plan
    to modify the contents of the lines (glyphs, glyph widths, etc.).
    -}
    layoutGetLines ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m [Pango.LayoutLine.LayoutLine]
        {- ^ __Returns:__ a 'GI.GLib.Structs.SList.SList' containing
    the lines in the layout. This points to internal data of the 'GI.Pango.Objects.Layout.Layout'
    and must be used with care. It will become invalid on any change to the layout\'s
    text or properties. -}
    layoutGetLines layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_lines layout'
        result' <- unpackGSList result
        result'' <- mapM (newBoxed Pango.LayoutLine.LayoutLine) result'
        touchManagedPtr layout
        return result''

    #if ENABLE_OVERLOADING
    data LayoutGetLinesMethodInfo
    instance (signature ~ (m [Pango.LayoutLine.LayoutLine]), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetLinesMethodInfo a signature where
        overloadedMethod _ = layoutGetLines

    #endif

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

    foreign import ccall "pango_layout_get_lines_readonly" pango_layout_get_lines_readonly ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO (Ptr (GSList (Ptr Pango.LayoutLine.LayoutLine)))

    {- |
    Returns the lines of the /@layout@/ as a list.

    This is a faster alternative to 'GI.Pango.Objects.Layout.layoutGetLines',
    but the user is not expected
    to modify the contents of the lines (glyphs, glyph widths, etc.).

    /Since: 1.16/
    -}
    layoutGetLinesReadonly ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m [Pango.LayoutLine.LayoutLine]
        {- ^ __Returns:__ a 'GI.GLib.Structs.SList.SList' containing
    the lines in the layout. This points to internal data of the 'GI.Pango.Objects.Layout.Layout' and
    must be used with care. It will become invalid on any change to the layout\'s
    text or properties.  No changes should be made to the lines. -}
    layoutGetLinesReadonly layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_lines_readonly layout'
        result' <- unpackGSList result
        result'' <- mapM (newBoxed Pango.LayoutLine.LayoutLine) result'
        touchManagedPtr layout
        return result''

    #if ENABLE_OVERLOADING
    data LayoutGetLinesReadonlyMethodInfo
    instance (signature ~ (m [Pango.LayoutLine.LayoutLine]), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetLinesReadonlyMethodInfo a signature where
        overloadedMethod _ = layoutGetLinesReadonly

    #endif

    -- method Layout::get_log_attrs
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attrs", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "Pango", name = "LogAttr"})), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n        location to store a pointer to an array of logical attributes\n        This value must be freed with g_free().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferContainer},Arg {argCName = "n_attrs", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of the attributes in the\n          array. (The stored value will be one more than the total number\n          of characters in the layout, since there need to be attributes\n          corresponding to both the position before the first character\n          and the position after the last character.)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : [Arg {argCName = "n_attrs", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of the attributes in the\n          array. (The stored value will be one more than the total number\n          of characters in the layout, since there need to be attributes\n          corresponding to both the position before the first character\n          and the position after the last character.)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_log_attrs" pango_layout_get_log_attrs ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr (Ptr Pango.LogAttr.LogAttr) ->      -- attrs : TCArray False (-1) 2 (TInterface (Name {namespace = "Pango", name = "LogAttr"}))
        Ptr Int32 ->                            -- n_attrs : TBasicType TInt
        IO ()

    {- |
    Retrieves an array of logical attributes for each character in
    the /@layout@/.
    -}
    layoutGetLogAttrs ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m ([Pango.LogAttr.LogAttr])
    layoutGetLogAttrs layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        attrs <- allocMem :: IO (Ptr (Ptr Pango.LogAttr.LogAttr))
        nAttrs <- allocMem :: IO (Ptr Int32)
        pango_layout_get_log_attrs layout' attrs nAttrs
        nAttrs' <- peek nAttrs
        attrs' <- peek attrs
        attrs'' <- (unpackBlockArrayWithLength 52 nAttrs') attrs'
        attrs''' <- mapM (newPtr Pango.LogAttr.LogAttr) attrs''
        freeMem attrs'
        touchManagedPtr layout
        freeMem attrs
        freeMem nAttrs
        return attrs'''

    #if ENABLE_OVERLOADING
    data LayoutGetLogAttrsMethodInfo
    instance (signature ~ (m ([Pango.LogAttr.LogAttr])), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetLogAttrsMethodInfo a signature where
        overloadedMethod _ = layoutGetLogAttrs

    #endif

    -- method Layout::get_log_attrs_readonly
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_attrs", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of the attributes in\n  the array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : [Arg {argCName = "n_attrs", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of the attributes in\n  the array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- returnType : Just (TCArray False (-1) 1 (TInterface (Name {namespace = "Pango", name = "LogAttr"})))
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_log_attrs_readonly" pango_layout_get_log_attrs_readonly ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr Int32 ->                            -- n_attrs : TBasicType TInt
        IO (Ptr Pango.LogAttr.LogAttr)

    {- |
    Retrieves an array of logical attributes for each character in
    the /@layout@/.

    This is a faster alternative to 'GI.Pango.Objects.Layout.layoutGetLogAttrs'.
    The returned array is part of /@layout@/ and must not be modified.
    Modifying the layout will invalidate the returned array.

    The number of attributes returned in /@nAttrs@/ will be one more
    than the total number of characters in the layout, since there
    need to be attributes corresponding to both the position before
    the first character and the position after the last character.

    /Since: 1.30/
    -}
    layoutGetLogAttrsReadonly ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m [Pango.LogAttr.LogAttr]
        {- ^ __Returns:__ an array of logical attributes -}
    layoutGetLogAttrsReadonly layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        nAttrs <- allocMem :: IO (Ptr Int32)
        result <- pango_layout_get_log_attrs_readonly layout' nAttrs
        nAttrs' <- peek nAttrs
        checkUnexpectedReturnNULL "layoutGetLogAttrsReadonly" result
        result' <- (unpackBlockArrayWithLength 52 nAttrs') result
        result'' <- mapM (newPtr Pango.LogAttr.LogAttr) result'
        touchManagedPtr layout
        freeMem nAttrs
        return result''

    #if ENABLE_OVERLOADING
    data LayoutGetLogAttrsReadonlyMethodInfo
    instance (signature ~ (m [Pango.LogAttr.LogAttr]), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetLogAttrsReadonlyMethodInfo a signature where
        overloadedMethod _ = layoutGetLogAttrsReadonly

    #endif

    -- method Layout::get_pixel_extents
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ink_rect", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle used to store the extents of the\n                  layout as drawn or %NULL to indicate that the result is\n                  not needed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "logical_rect", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle used to store the logical\n                      extents of the layout or %NULL to indicate that the\n                      result is not needed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_pixel_extents" pango_layout_get_pixel_extents ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr Pango.Rectangle.Rectangle ->        -- ink_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        Ptr Pango.Rectangle.Rectangle ->        -- logical_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        IO ()

    {- |
    Computes the logical and ink extents of /@layout@/ in device units.
    This function just calls 'GI.Pango.Objects.Layout.layoutGetExtents' followed by
    two 'GI.Pango.Functions.extentsToPixels' calls, rounding /@inkRect@/ and /@logicalRect@/
    such that the rounded rectangles fully contain the unrounded one (that is,
    passes them as first argument to 'GI.Pango.Functions.extentsToPixels').
    -}
    layoutGetPixelExtents ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
    layoutGetPixelExtents layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        inkRect <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        logicalRect <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        pango_layout_get_pixel_extents layout' inkRect logicalRect
        inkRect' <- (wrapPtr Pango.Rectangle.Rectangle) inkRect
        logicalRect' <- (wrapPtr Pango.Rectangle.Rectangle) logicalRect
        touchManagedPtr layout
        return (inkRect', logicalRect')

    #if ENABLE_OVERLOADING
    data LayoutGetPixelExtentsMethodInfo
    instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetPixelExtentsMethodInfo a signature where
        overloadedMethod _ = layoutGetPixelExtents

    #endif

    -- method Layout::get_pixel_size
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the logical width, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the logical height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_pixel_size" pango_layout_get_pixel_size ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr Int32 ->                            -- width : TBasicType TInt
        Ptr Int32 ->                            -- height : TBasicType TInt
        IO ()

    {- |
    Determines the logical width and height of a 'GI.Pango.Objects.Layout.Layout'
    in device units. ('GI.Pango.Objects.Layout.layoutGetSize' returns the width
    and height scaled by 'GI.Pango.Constants.SCALE'.) This
    is simply a convenience function around
    'GI.Pango.Objects.Layout.layoutGetPixelExtents'.
    -}
    layoutGetPixelSize ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m ((Int32, Int32))
    layoutGetPixelSize layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        width <- allocMem :: IO (Ptr Int32)
        height <- allocMem :: IO (Ptr Int32)
        pango_layout_get_pixel_size layout' width height
        width' <- peek width
        height' <- peek height
        touchManagedPtr layout
        freeMem width
        freeMem height
        return (width', height')

    #if ENABLE_OVERLOADING
    data LayoutGetPixelSizeMethodInfo
    instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetPixelSizeMethodInfo a signature where
        overloadedMethod _ = layoutGetPixelSize

    #endif

    -- method Layout::get_serial
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_serial" pango_layout_get_serial ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Word32

    {- |
    Returns the current serial number of /@layout@/.  The serial number is
    initialized to an small number  larger than zero when a new layout
    is created and is increased whenever the layout is changed using any
    of the setter functions, or the 'GI.Pango.Objects.Context.Context' it uses has changed.
    The serial may wrap, but will never have the value 0. Since it
    can wrap, never compare it with \"less than\", always use \"not equals\".

    This can be used to automatically detect changes to a 'GI.Pango.Objects.Layout.Layout', and
    is useful for example to decide whether a layout needs redrawing.
    To force the serial to be increased, use 'GI.Pango.Objects.Layout.layoutContextChanged'.

    /Since: 1.32.4/
    -}
    layoutGetSerial ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Word32
        {- ^ __Returns:__ The current serial number of /@layout@/. -}
    layoutGetSerial layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_serial layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetSerialMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetSerialMethodInfo a signature where
        overloadedMethod _ = layoutGetSerial

    #endif

    -- method Layout::get_single_paragraph_mode
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_single_paragraph_mode" pango_layout_get_single_paragraph_mode ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CInt

    {- |
    Obtains the value set by 'GI.Pango.Objects.Layout.layoutSetSingleParagraphMode'.
    -}
    layoutGetSingleParagraphMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the layout does not break paragraphs at
    paragraph separator characters, 'False' otherwise. -}
    layoutGetSingleParagraphMode layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_single_paragraph_mode layout'
        let result' = (/= 0) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetSingleParagraphModeMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetSingleParagraphModeMethodInfo a signature where
        overloadedMethod _ = layoutGetSingleParagraphMode

    #endif

    -- method Layout::get_size
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the logical width, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the logical height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_get_size" pango_layout_get_size ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr Int32 ->                            -- width : TBasicType TInt
        Ptr Int32 ->                            -- height : TBasicType TInt
        IO ()

    {- |
    Determines the logical width and height of a 'GI.Pango.Objects.Layout.Layout'
    in Pango units (device units scaled by 'GI.Pango.Constants.SCALE'). This
    is simply a convenience function around 'GI.Pango.Objects.Layout.layoutGetExtents'.
    -}
    layoutGetSize ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m ((Int32, Int32))
    layoutGetSize layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        width <- allocMem :: IO (Ptr Int32)
        height <- allocMem :: IO (Ptr Int32)
        pango_layout_get_size layout' width height
        width' <- peek width
        height' <- peek height
        touchManagedPtr layout
        freeMem width
        freeMem height
        return (width', height')

    #if ENABLE_OVERLOADING
    data LayoutGetSizeMethodInfo
    instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetSizeMethodInfo a signature where
        overloadedMethod _ = layoutGetSize

    #endif

    -- method Layout::get_spacing
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_spacing" pango_layout_get_spacing ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Int32

    {- |
    Gets the amount of spacing between the lines of the layout.
    -}
    layoutGetSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Int32
        {- ^ __Returns:__ the spacing in Pango units. -}
    layoutGetSpacing layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_spacing layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetSpacingMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetSpacingMethodInfo a signature where
        overloadedMethod _ = layoutGetSpacing

    #endif

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

    foreign import ccall "pango_layout_get_tabs" pango_layout_get_tabs ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO (Ptr Pango.TabArray.TabArray)

    {- |
    Gets the current 'GI.Pango.Structs.TabArray.TabArray' used by this layout. If no
    'GI.Pango.Structs.TabArray.TabArray' has been set, then the default tabs are in use
    and 'Nothing' is returned. Default tabs are every 8 spaces.
    The return value should be freed with 'GI.Pango.Structs.TabArray.tabArrayFree'.
    -}
    layoutGetTabs ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m (Maybe Pango.TabArray.TabArray)
        {- ^ __Returns:__ a copy of the tabs for this layout, or
    'Nothing'. -}
    layoutGetTabs layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_tabs layout'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (wrapBoxed Pango.TabArray.TabArray) result'
            return result''
        touchManagedPtr layout
        return maybeResult

    #if ENABLE_OVERLOADING
    data LayoutGetTabsMethodInfo
    instance (signature ~ (m (Maybe Pango.TabArray.TabArray)), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetTabsMethodInfo a signature where
        overloadedMethod _ = layoutGetTabs

    #endif

    -- method Layout::get_text
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_text" pango_layout_get_text ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CString

    {- |
    Gets the text in the layout. The returned text should not
    be freed or modified.
    -}
    layoutGetText ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m T.Text
        {- ^ __Returns:__ the text in the /@layout@/. -}
    layoutGetText layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_text layout'
        checkUnexpectedReturnNULL "layoutGetText" result
        result' <- cstringToText result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetTextMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetTextMethodInfo a signature where
        overloadedMethod _ = layoutGetText

    #endif

    -- method Layout::get_unknown_glyphs_count
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_unknown_glyphs_count" pango_layout_get_unknown_glyphs_count ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Int32

    {- |
    Counts the number unknown glyphs in /@layout@/.  That is, zero if
    glyphs for all characters in the layout text were found, or more
    than zero otherwise.

    This function can be used to determine if there are any fonts
    available to render all characters in a certain string, or when
    used in combination with 'GI.Pango.Enums.AttrTypeFallback', to check if a
    certain font supports all the characters in the string.

    /Since: 1.16/
    -}
    layoutGetUnknownGlyphsCount ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Int32
        {- ^ __Returns:__ The number of unknown glyphs in /@layout@/. -}
    layoutGetUnknownGlyphsCount layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_unknown_glyphs_count layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetUnknownGlyphsCountMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetUnknownGlyphsCountMethodInfo a signature where
        overloadedMethod _ = layoutGetUnknownGlyphsCount

    #endif

    -- method Layout::get_width
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_width" pango_layout_get_width ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO Int32

    {- |
    Gets the width to which the lines of the 'GI.Pango.Objects.Layout.Layout' should wrap.
    -}
    layoutGetWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Int32
        {- ^ __Returns:__ the width in Pango units, or -1 if no width set. -}
    layoutGetWidth layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_width layout'
        touchManagedPtr layout
        return result

    #if ENABLE_OVERLOADING
    data LayoutGetWidthMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetWidthMethodInfo a signature where
        overloadedMethod _ = layoutGetWidth

    #endif

    -- method Layout::get_wrap
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_get_wrap" pango_layout_get_wrap ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CUInt

    {- |
    Gets the wrap mode for the layout.

    Use 'GI.Pango.Objects.Layout.layoutIsWrapped' to query whether any paragraphs
    were actually wrapped.
    -}
    layoutGetWrap ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Pango.Enums.WrapMode
        {- ^ __Returns:__ active wrap mode. -}
    layoutGetWrap layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_get_wrap layout'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutGetWrapMethodInfo
    instance (signature ~ (m Pango.Enums.WrapMode), MonadIO m, IsLayout a) => O.MethodInfo LayoutGetWrapMethodInfo a signature where
        overloadedMethod _ = layoutGetWrap

    #endif

    -- method Layout::index_to_line_x
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the byte index of a grapheme within the layout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "trailing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an integer indicating the edge of the grapheme to retrieve the\n            position of. If > 0, the trailing edge of the grapheme, if 0,\n            the leading of the grapheme.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store resulting line index. (which will\n              between 0 and pango_layout_get_line_count(layout) - 1), or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "x_pos", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store resulting position within line\n             (%PANGO_SCALE units per device unit), 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 "pango_layout_index_to_line_x" pango_layout_index_to_line_x ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- index_ : TBasicType TInt
        CInt ->                                 -- trailing : TBasicType TBoolean
        Ptr Int32 ->                            -- line : TBasicType TInt
        Ptr Int32 ->                            -- x_pos : TBasicType TInt
        IO ()

    {- |
    Converts from byte /@index_@/ within the /@layout@/ to line and X position.
    (X position is measured from the left edge of the line)
    -}
    layoutIndexToLineX ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Int32
        {- ^ /@index_@/: the byte index of a grapheme within the layout. -}
        -> Bool
        {- ^ /@trailing@/: an integer indicating the edge of the grapheme to retrieve the
                position of. If > 0, the trailing edge of the grapheme, if 0,
                the leading of the grapheme. -}
        -> m ((Int32, Int32))
    layoutIndexToLineX layout index_ trailing = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        let trailing' = (fromIntegral . fromEnum) trailing
        line <- allocMem :: IO (Ptr Int32)
        xPos <- allocMem :: IO (Ptr Int32)
        pango_layout_index_to_line_x layout' index_ trailing' line xPos
        line' <- peek line
        xPos' <- peek xPos
        touchManagedPtr layout
        freeMem line
        freeMem xPos
        return (line', xPos')

    #if ENABLE_OVERLOADING
    data LayoutIndexToLineXMethodInfo
    instance (signature ~ (Int32 -> Bool -> m ((Int32, Int32))), MonadIO m, IsLayout a) => O.MethodInfo LayoutIndexToLineXMethodInfo a signature where
        overloadedMethod _ = layoutIndexToLineX

    #endif

    -- method Layout::index_to_pos
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "byte index within @layout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle in which to store the position of the grapheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_index_to_pos" pango_layout_index_to_pos ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- index_ : TBasicType TInt
        Ptr Pango.Rectangle.Rectangle ->        -- pos : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        IO ()

    {- |
    Converts from an index within a 'GI.Pango.Objects.Layout.Layout' to the onscreen position
    corresponding to the grapheme at that index, which is represented
    as rectangle.  Note that \<literal>pos->x\<\/literal> is always the leading
    edge of the grapheme and \<literal>pos->x + pos->width\<\/literal> the trailing
    edge of the grapheme. If the directionality of the grapheme is right-to-left,
    then \<literal>pos->width\<\/literal> will be negative.
    -}
    layoutIndexToPos ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Int32
        {- ^ /@index_@/: byte index within /@layout@/ -}
        -> m (Pango.Rectangle.Rectangle)
    layoutIndexToPos layout index_ = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        pos <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        pango_layout_index_to_pos layout' index_ pos
        pos' <- (wrapPtr Pango.Rectangle.Rectangle) pos
        touchManagedPtr layout
        return pos'

    #if ENABLE_OVERLOADING
    data LayoutIndexToPosMethodInfo
    instance (signature ~ (Int32 -> m (Pango.Rectangle.Rectangle)), MonadIO m, IsLayout a) => O.MethodInfo LayoutIndexToPosMethodInfo a signature where
        overloadedMethod _ = layoutIndexToPos

    #endif

    -- method Layout::is_ellipsized
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_is_ellipsized" pango_layout_is_ellipsized ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CInt

    {- |
    Queries whether the layout had to ellipsize any paragraphs.

    This returns 'True' if the ellipsization mode for /@layout@/
    is not 'GI.Pango.Enums.EllipsizeModeNone', a positive width is set on /@layout@/,
    and there are paragraphs exceeding that width that have to be
    ellipsized.

    /Since: 1.16/
    -}
    layoutIsEllipsized ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if any paragraphs had to be ellipsized, 'False'
    otherwise. -}
    layoutIsEllipsized layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_is_ellipsized layout'
        let result' = (/= 0) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutIsEllipsizedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsLayout a) => O.MethodInfo LayoutIsEllipsizedMethodInfo a signature where
        overloadedMethod _ = layoutIsEllipsized

    #endif

    -- method Layout::is_wrapped
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "pango_layout_is_wrapped" pango_layout_is_wrapped ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        IO CInt

    {- |
    Queries whether the layout had to wrap any paragraphs.

    This returns 'True' if a positive width is set on /@layout@/,
    ellipsization mode of /@layout@/ is set to 'GI.Pango.Enums.EllipsizeModeNone',
    and there are paragraphs exceeding the layout width that have
    to be wrapped.

    /Since: 1.16/
    -}
    layoutIsWrapped ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if any paragraphs had to be wrapped, 'False'
    otherwise. -}
    layoutIsWrapped layout = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        result <- pango_layout_is_wrapped layout'
        let result' = (/= 0) result
        touchManagedPtr layout
        return result'

    #if ENABLE_OVERLOADING
    data LayoutIsWrappedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsLayout a) => O.MethodInfo LayoutIsWrappedMethodInfo a signature where
        overloadedMethod _ = layoutIsWrapped

    #endif

    -- method Layout::move_cursor_visually
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "strong", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the moving cursor is the strong cursor or the\n               weak cursor. The strong cursor is the cursor corresponding\n               to text insertion in the base direction for the layout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the byte index of the grapheme for the old index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_trailing", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if 0, the cursor was at the leading edge of the\n               grapheme indicated by @old_index, if > 0, the cursor\n               was at the trailing edge.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "direction to move cursor. A negative\n               value indicates motion to the left.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_index", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the new cursor byte index. A value of -1\n               indicates that the cursor has been moved off the beginning\n               of the layout. A value of %G_MAXINT indicates that\n               the cursor has been moved off the end of the layout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "new_trailing", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of characters to move forward from the\n               location returned for @new_index to get the position\n               where the cursor should be displayed. This allows\n               distinguishing the position at the beginning of one\n               line from the position at the end of the preceding\n               line. @new_index is always on the line where the\n               cursor should be displayed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_move_cursor_visually" pango_layout_move_cursor_visually ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CInt ->                                 -- strong : TBasicType TBoolean
        Int32 ->                                -- old_index : TBasicType TInt
        Int32 ->                                -- old_trailing : TBasicType TInt
        Int32 ->                                -- direction : TBasicType TInt
        Ptr Int32 ->                            -- new_index : TBasicType TInt
        Ptr Int32 ->                            -- new_trailing : TBasicType TInt
        IO ()

    {- |
    Computes a new cursor position from an old position and
    a count of positions to move visually. If /@direction@/ is positive,
    then the new strong cursor position will be one position
    to the right of the old cursor position. If /@direction@/ is negative,
    then the new strong cursor position will be one position
    to the left of the old cursor position.

    In the presence of bidirectional text, the correspondence
    between logical and visual order will depend on the direction
    of the current run, and there may be jumps when the cursor
    is moved off of the end of a run.

    Motion here is in cursor positions, not in characters, so a
    single call to 'GI.Pango.Objects.Layout.layoutMoveCursorVisually' may move the
    cursor over multiple characters when multiple characters combine
    to form a single grapheme.
    -}
    layoutMoveCursorVisually ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout'. -}
        -> Bool
        {- ^ /@strong@/: whether the moving cursor is the strong cursor or the
                   weak cursor. The strong cursor is the cursor corresponding
                   to text insertion in the base direction for the layout. -}
        -> Int32
        {- ^ /@oldIndex@/: the byte index of the grapheme for the old index -}
        -> Int32
        {- ^ /@oldTrailing@/: if 0, the cursor was at the leading edge of the
                   grapheme indicated by /@oldIndex@/, if > 0, the cursor
                   was at the trailing edge. -}
        -> Int32
        {- ^ /@direction@/: direction to move cursor. A negative
                   value indicates motion to the left. -}
        -> m ((Int32, Int32))
    layoutMoveCursorVisually layout strong oldIndex oldTrailing direction = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        let strong' = (fromIntegral . fromEnum) strong
        newIndex <- allocMem :: IO (Ptr Int32)
        newTrailing <- allocMem :: IO (Ptr Int32)
        pango_layout_move_cursor_visually layout' strong' oldIndex oldTrailing direction newIndex newTrailing
        newIndex' <- peek newIndex
        newTrailing' <- peek newTrailing
        touchManagedPtr layout
        freeMem newIndex
        freeMem newTrailing
        return (newIndex', newTrailing')

    #if ENABLE_OVERLOADING
    data LayoutMoveCursorVisuallyMethodInfo
    instance (signature ~ (Bool -> Int32 -> Int32 -> Int32 -> m ((Int32, Int32))), MonadIO m, IsLayout a) => O.MethodInfo LayoutMoveCursorVisuallyMethodInfo a signature where
        overloadedMethod _ = layoutMoveCursorVisually

    #endif

    -- method Layout::set_alignment
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "the alignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_alignment" pango_layout_set_alignment ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CUInt ->                                -- alignment : TInterface (Name {namespace = "Pango", name = "Alignment"})
        IO ()

    {- |
    Sets the alignment for the layout: how partial lines are
    positioned within the horizontal space available.
    -}
    layoutSetAlignment ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Pango.Enums.Alignment
        {- ^ /@alignment@/: the alignment -}
        -> m ()
    layoutSetAlignment layout alignment = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        let alignment' = (fromIntegral . fromEnum) alignment
        pango_layout_set_alignment layout' alignment'
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetAlignmentMethodInfo
    instance (signature ~ (Pango.Enums.Alignment -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetAlignmentMethodInfo a signature where
        overloadedMethod _ = layoutSetAlignment

    #endif

    -- method Layout::set_attributes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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, can be %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_attributes" pango_layout_set_attributes ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr Pango.AttrList.AttrList ->          -- attrs : TInterface (Name {namespace = "Pango", name = "AttrList"})
        IO ()

    {- |
    Sets the text attributes for a layout object.
    References /@attrs@/, so the caller can unref its reference.
    -}
    layoutSetAttributes ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Maybe (Pango.AttrList.AttrList)
        {- ^ /@attrs@/: a 'GI.Pango.Structs.AttrList.AttrList', can be 'Nothing' -}
        -> m ()
    layoutSetAttributes layout attrs = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        maybeAttrs <- case attrs of
            Nothing -> return nullPtr
            Just jAttrs -> do
                jAttrs' <- unsafeManagedPtrGetPtr jAttrs
                return jAttrs'
        pango_layout_set_attributes layout' maybeAttrs
        touchManagedPtr layout
        whenJust attrs touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetAttributesMethodInfo
    instance (signature ~ (Maybe (Pango.AttrList.AttrList) -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetAttributesMethodInfo a signature where
        overloadedMethod _ = layoutSetAttributes

    #endif

    -- method Layout::set_auto_dir
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "auto_dir", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %TRUE, compute the bidirectional base direction\n  from the layout's contents.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_auto_dir" pango_layout_set_auto_dir ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CInt ->                                 -- auto_dir : TBasicType TBoolean
        IO ()

    {- |
    Sets whether to calculate the bidirectional base direction
    for the layout according to the contents of the layout;
    when this flag is on (the default), then paragraphs in
       /@layout@/ that begin with strong right-to-left characters
    (Arabic and Hebrew principally), will have right-to-left
    layout, paragraphs with letters from other scripts will
    have left-to-right layout. Paragraphs with only neutral
    characters get their direction from the surrounding paragraphs.

    When 'False', the choice between left-to-right and
    right-to-left layout is done according to the base direction
    of the layout\'s 'GI.Pango.Objects.Context.Context'. (See 'GI.Pango.Objects.Context.contextSetBaseDir').

    When the auto-computed direction of a paragraph differs from the
    base direction of the context, the interpretation of
    'GI.Pango.Enums.AlignmentLeft' and 'GI.Pango.Enums.AlignmentRight' are swapped.

    /Since: 1.4/
    -}
    layoutSetAutoDir ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Bool
        {- ^ /@autoDir@/: if 'True', compute the bidirectional base direction
      from the layout\'s contents. -}
        -> m ()
    layoutSetAutoDir layout autoDir = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        let autoDir' = (fromIntegral . fromEnum) autoDir
        pango_layout_set_auto_dir layout' autoDir'
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetAutoDirMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetAutoDirMethodInfo a signature where
        overloadedMethod _ = layoutSetAutoDir

    #endif

    -- method Layout::set_ellipsize
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ellipsize", argType = TInterface (Name {namespace = "Pango", name = "EllipsizeMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new ellipsization mode for @layout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_ellipsize" pango_layout_set_ellipsize ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CUInt ->                                -- ellipsize : TInterface (Name {namespace = "Pango", name = "EllipsizeMode"})
        IO ()

    {- |
    Sets the type of ellipsization being performed for /@layout@/.
    Depending on the ellipsization mode /@ellipsize@/ text is
    removed from the start, middle, or end of text so they
    fit within the width and height of layout set with
    'GI.Pango.Objects.Layout.layoutSetWidth' and 'GI.Pango.Objects.Layout.layoutSetHeight'.

    If the layout contains characters such as newlines that
    force it to be layed out in multiple paragraphs, then whether
    each paragraph is ellipsized separately or the entire layout
    is ellipsized as a whole depends on the set height of the layout.
    See 'GI.Pango.Objects.Layout.layoutSetHeight' for details.

    /Since: 1.6/
    -}
    layoutSetEllipsize ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Pango.Enums.EllipsizeMode
        {- ^ /@ellipsize@/: the new ellipsization mode for /@layout@/ -}
        -> m ()
    layoutSetEllipsize layout ellipsize = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        let ellipsize' = (fromIntegral . fromEnum) ellipsize
        pango_layout_set_ellipsize layout' ellipsize'
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetEllipsizeMethodInfo
    instance (signature ~ (Pango.Enums.EllipsizeMode -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetEllipsizeMethodInfo a signature where
        overloadedMethod _ = layoutSetEllipsize

    #endif

    -- method Layout::set_font_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "desc", argType = TInterface (Name {namespace = "Pango", name = "FontDescription"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new #PangoFontDescription, or %NULL to unset the\n       current font description", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_font_description" pango_layout_set_font_description ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr Pango.FontDescription.FontDescription -> -- desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
        IO ()

    {- |
    Sets the default font description for the layout. If no font
    description is set on the layout, the font description from
    the layout\'s context is used.
    -}
    layoutSetFontDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Maybe (Pango.FontDescription.FontDescription)
        {- ^ /@desc@/: the new 'GI.Pango.Structs.FontDescription.FontDescription', or 'Nothing' to unset the
           current font description -}
        -> m ()
    layoutSetFontDescription layout desc = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        maybeDesc <- case desc of
            Nothing -> return nullPtr
            Just jDesc -> do
                jDesc' <- unsafeManagedPtrGetPtr jDesc
                return jDesc'
        pango_layout_set_font_description layout' maybeDesc
        touchManagedPtr layout
        whenJust desc touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetFontDescriptionMethodInfo
    instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetFontDescriptionMethodInfo a signature where
        overloadedMethod _ = layoutSetFontDescription

    #endif

    -- method Layout::set_height
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired height of the layout in Pango units if positive,\n         or desired number of lines if negative.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_height" pango_layout_set_height ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- height : TBasicType TInt
        IO ()

    {- |
    Sets the height to which the 'GI.Pango.Objects.Layout.Layout' should be ellipsized at.  There
    are two different behaviors, based on whether /@height@/ is positive or
    negative.

    If /@height@/ is positive, it will be the maximum height of the layout.  Only
    lines would be shown that would fit, and if there is any text omitted,
    an ellipsis added.  At least one line is included in each paragraph regardless
    of how small the height value is.  A value of zero will render exactly one
    line for the entire layout.

    If /@height@/ is negative, it will be the (negative of) maximum number of lines per
    paragraph.  That is, the total number of lines shown may well be more than
    this value if the layout contains multiple paragraphs of text.
    The default value of -1 means that first line of each paragraph is ellipsized.
    This behvaior may be changed in the future to act per layout instead of per
    paragraph.  File a bug against pango at \<ulink
    url=\"http:\/\/bugzilla.gnome.org\/\">http:\/\/bugzilla.gnome.org\/\<\/ulink> if your
    code relies on this behavior.

    Height setting only has effect if a positive width is set on
    /@layout@/ and ellipsization mode of /@layout@/ is not 'GI.Pango.Enums.EllipsizeModeNone'.
    The behavior is undefined if a height other than -1 is set and
    ellipsization mode is set to 'GI.Pango.Enums.EllipsizeModeNone', and may change in the
    future.

    /Since: 1.20/
    -}
    layoutSetHeight ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout'. -}
        -> Int32
        {- ^ /@height@/: the desired height of the layout in Pango units if positive,
             or desired number of lines if negative. -}
        -> m ()
    layoutSetHeight layout height = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        pango_layout_set_height layout' height
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetHeightMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetHeightMethodInfo a signature where
        overloadedMethod _ = layoutSetHeight

    #endif

    -- method Layout::set_indent
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "indent", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount by which to indent.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_indent" pango_layout_set_indent ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- indent : TBasicType TInt
        IO ()

    {- |
    Sets the width in Pango units to indent each paragraph. A negative value
    of /@indent@/ will produce a hanging indentation. That is, the first line will
    have the full width, and subsequent lines will be indented by the
    absolute value of /@indent@/.

    The indent setting is ignored if layout alignment is set to
    'GI.Pango.Enums.AlignmentCenter'.
    -}
    layoutSetIndent ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout'. -}
        -> Int32
        {- ^ /@indent@/: the amount by which to indent. -}
        -> m ()
    layoutSetIndent layout indent = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        pango_layout_set_indent layout' indent
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetIndentMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetIndentMethodInfo a signature where
        overloadedMethod _ = layoutSetIndent

    #endif

    -- method Layout::set_justify
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 lines in the layout 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 "pango_layout_set_justify" pango_layout_set_justify ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CInt ->                                 -- justify : TBasicType TBoolean
        IO ()

    {- |
    Sets whether each complete line should be stretched to
    fill the entire width of the layout. This stretching is typically
    done by adding whitespace, but for some scripts (such as Arabic),
    the justification may be done in more complex ways, like extending
    the characters.

    Note that this setting is not implemented and so is ignored in Pango
    older than 1.18.
    -}
    layoutSetJustify ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Bool
        {- ^ /@justify@/: whether the lines in the layout should be justified. -}
        -> m ()
    layoutSetJustify layout justify = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        let justify' = (fromIntegral . fromEnum) justify
        pango_layout_set_justify layout' justify'
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetJustifyMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetJustifyMethodInfo a signature where
        overloadedMethod _ = layoutSetJustify

    #endif

    -- method Layout::set_markup
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "marked-up text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of marked-up text in bytes, or -1 if @markup is\n         null-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_markup" pango_layout_set_markup ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CString ->                              -- markup : TBasicType TUTF8
        Int32 ->                                -- length : TBasicType TInt
        IO ()

    {- |
    Same as 'GI.Pango.Objects.Layout.layoutSetMarkupWithAccel', but
    the markup text isn\'t scanned for accelerators.
    -}
    layoutSetMarkup ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> T.Text
        {- ^ /@markup@/: marked-up text -}
        -> Int32
        {- ^ /@length@/: length of marked-up text in bytes, or -1 if /@markup@/ is
             null-terminated -}
        -> m ()
    layoutSetMarkup layout markup length_ = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        markup' <- textToCString markup
        pango_layout_set_markup layout' markup' length_
        touchManagedPtr layout
        freeMem markup'
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetMarkupMethodInfo
    instance (signature ~ (T.Text -> Int32 -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetMarkupMethodInfo a signature where
        overloadedMethod _ = layoutSetMarkup

    #endif

    -- XXX Could not generate method Layout::set_markup_with_accel
    -- Error was : Not implemented: "Don't know how to allocate \"accel_char\" of type TBasicType TUniChar"
    #if ENABLE_OVERLOADING
    -- XXX: Dummy instance, since code generation failed.
    -- Please file a bug at http://github.com/haskell-gi/haskell-gi.
    data LayoutSetMarkupWithAccelMethodInfo
    instance (p ~ (), o ~ O.MethodResolutionFailed "setMarkupWithAccel" Layout) => O.MethodInfo LayoutSetMarkupWithAccelMethodInfo o p where
        overloadedMethod _ = undefined
    #endif

    -- method Layout::set_single_paragraph_mode
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "new setting", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_single_paragraph_mode" pango_layout_set_single_paragraph_mode ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CInt ->                                 -- setting : TBasicType TBoolean
        IO ()

    {- |
    If /@setting@/ is 'True', do not treat newlines and similar characters
    as paragraph separators; instead, keep all text in a single paragraph,
    and display a glyph for paragraph separator characters. Used when
    you want to allow editing of newlines on a single text line.
    -}
    layoutSetSingleParagraphMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Bool
        {- ^ /@setting@/: new setting -}
        -> m ()
    layoutSetSingleParagraphMode layout setting = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        let setting' = (fromIntegral . fromEnum) setting
        pango_layout_set_single_paragraph_mode layout' setting'
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetSingleParagraphModeMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetSingleParagraphModeMethodInfo a signature where
        overloadedMethod _ = layoutSetSingleParagraphMode

    #endif

    -- method Layout::set_spacing
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "spacing", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of spacing", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_spacing" pango_layout_set_spacing ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- spacing : TBasicType TInt
        IO ()

    {- |
    Sets the amount of spacing in Pango unit between the lines of the
    layout.
    -}
    layoutSetSpacing ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout'. -}
        -> Int32
        {- ^ /@spacing@/: the amount of spacing -}
        -> m ()
    layoutSetSpacing layout spacing = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        pango_layout_set_spacing layout' spacing
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetSpacingMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetSpacingMethodInfo a signature where
        overloadedMethod _ = layoutSetSpacing

    #endif

    -- method Layout::set_tabs
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tabs", argType = TInterface (Name {namespace = "Pango", name = "TabArray"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #PangoTabArray, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_tabs" pango_layout_set_tabs ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Ptr Pango.TabArray.TabArray ->          -- tabs : TInterface (Name {namespace = "Pango", name = "TabArray"})
        IO ()

    {- |
    Sets the tabs to use for /@layout@/, overriding the default tabs
    (by default, tabs are every 8 spaces). If /@tabs@/ is 'Nothing', the default
    tabs are reinstated. /@tabs@/ is copied into the layout; you must
    free your copy of /@tabs@/ yourself.
    -}
    layoutSetTabs ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Maybe (Pango.TabArray.TabArray)
        {- ^ /@tabs@/: a 'GI.Pango.Structs.TabArray.TabArray', or 'Nothing' -}
        -> m ()
    layoutSetTabs layout tabs = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        maybeTabs <- case tabs of
            Nothing -> return nullPtr
            Just jTabs -> do
                jTabs' <- unsafeManagedPtrGetPtr jTabs
                return jTabs'
        pango_layout_set_tabs layout' maybeTabs
        touchManagedPtr layout
        whenJust tabs touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetTabsMethodInfo
    instance (signature ~ (Maybe (Pango.TabArray.TabArray) -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetTabsMethodInfo a signature where
        overloadedMethod _ = layoutSetTabs

    #endif

    -- method Layout::set_text
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", 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 "a valid UTF-8 string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "maximum length of @text, in bytes. -1 indicates that\n         the string is nul-terminated and the length should be\n         calculated.  The text will also be truncated on\n         encountering a nul-termination even when @length is\n         positive.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_text" pango_layout_set_text ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CString ->                              -- text : TBasicType TUTF8
        Int32 ->                                -- length : TBasicType TInt
        IO ()

    {- |
    Sets the text of the layout.

    Note that if you have used
    'GI.Pango.Objects.Layout.layoutSetMarkup' or 'GI.Pango.Objects.Layout.layoutSetMarkupWithAccel' on
    /@layout@/ before, you may want to call 'GI.Pango.Objects.Layout.layoutSetAttributes' to clear
    the attributes set on the layout from the markup as this function does not
    clear attributes.
    -}
    layoutSetText ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> T.Text
        {- ^ /@text@/: a valid UTF-8 string -}
        -> Int32
        {- ^ /@length@/: maximum length of /@text@/, in bytes. -1 indicates that
             the string is nul-terminated and the length should be
             calculated.  The text will also be truncated on
             encountering a nul-termination even when /@length@/ is
             positive. -}
        -> m ()
    layoutSetText layout text length_ = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        text' <- textToCString text
        pango_layout_set_text layout' text' length_
        touchManagedPtr layout
        freeMem text'
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetTextMethodInfo
    instance (signature ~ (T.Text -> Int32 -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetTextMethodInfo a signature where
        overloadedMethod _ = layoutSetText

    #endif

    -- method Layout::set_width
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired width in Pango units, or -1 to indicate that no\n        wrapping or ellipsization should be performed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_layout_set_width" pango_layout_set_width ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- width : TBasicType TInt
        IO ()

    {- |
    Sets the width to which the lines of the 'GI.Pango.Objects.Layout.Layout' should wrap or
    ellipsized.  The default value is -1: no width set.
    -}
    layoutSetWidth ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout'. -}
        -> Int32
        {- ^ /@width@/: the desired width in Pango units, or -1 to indicate that no
            wrapping or ellipsization should be performed. -}
        -> m ()
    layoutSetWidth layout width = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        pango_layout_set_width layout' width
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetWidthMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetWidthMethodInfo a signature where
        overloadedMethod _ = layoutSetWidth

    #endif

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

    foreign import ccall "pango_layout_set_wrap" pango_layout_set_wrap ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        CUInt ->                                -- wrap : TInterface (Name {namespace = "Pango", name = "WrapMode"})
        IO ()

    {- |
    Sets the wrap mode; the wrap mode only has effect if a width
    is set on the layout with 'GI.Pango.Objects.Layout.layoutSetWidth'.
    To turn off wrapping, set the width to -1.
    -}
    layoutSetWrap ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Pango.Enums.WrapMode
        {- ^ /@wrap@/: the wrap mode -}
        -> m ()
    layoutSetWrap layout wrap = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        let wrap' = (fromIntegral . fromEnum) wrap
        pango_layout_set_wrap layout' wrap'
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data LayoutSetWrapMethodInfo
    instance (signature ~ (Pango.Enums.WrapMode -> m ()), MonadIO m, IsLayout a) => O.MethodInfo LayoutSetWrapMethodInfo a signature where
        overloadedMethod _ = layoutSetWrap

    #endif

    -- method Layout::xy_to_index
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X offset (in Pango units)\n            from the left edge of the layout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the Y offset (in Pango units)\n            from the top edge of the layout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store calculated byte index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "trailing", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store a integer indicating where\n            in the grapheme the user clicked. It will either\n            be zero, or the number of characters in the\n            grapheme. 0 represents the leading edge of the grapheme.", 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 "pango_layout_xy_to_index" pango_layout_xy_to_index ::
        Ptr Layout ->                           -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        Ptr Int32 ->                            -- index_ : TBasicType TInt
        Ptr Int32 ->                            -- trailing : TBasicType TInt
        IO CInt

    {- |
    Converts from X and Y position within a layout to the byte
    index to the character at that logical position. If the
    Y position is not inside the layout, the closest position is chosen
    (the position will be clamped inside the layout). If the
    X position is not within the layout, then the start or the
    end of the line is chosen as described for 'GI.Pango.Structs.LayoutLine.layoutLineXToIndex'.
    If either the X or Y positions were not inside the layout, then the
    function returns 'False'; on an exact hit, it returns 'True'.
    -}
    layoutXyToIndex ::
        (B.CallStack.HasCallStack, MonadIO m, IsLayout a) =>
        a
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Int32
        {- ^ /@x@/: the X offset (in Pango units)
                from the left edge of the layout. -}
        -> Int32
        {- ^ /@y@/: the Y offset (in Pango units)
                from the top edge of the layout -}
        -> m ((Bool, Int32, Int32))
        {- ^ __Returns:__ 'True' if the coordinates were inside text, 'False' otherwise. -}
    layoutXyToIndex layout x y = liftIO $ do
        layout' <- unsafeManagedPtrCastPtr layout
        index_ <- allocMem :: IO (Ptr Int32)
        trailing <- allocMem :: IO (Ptr Int32)
        result <- pango_layout_xy_to_index layout' x y index_ trailing
        let result' = (/= 0) result
        index_' <- peek index_
        trailing' <- peek trailing
        touchManagedPtr layout
        freeMem index_
        freeMem trailing
        return (result', index_', trailing')

    #if ENABLE_OVERLOADING
    data LayoutXyToIndexMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m ((Bool, Int32, Int32))), MonadIO m, IsLayout a) => O.MethodInfo LayoutXyToIndexMethodInfo a signature where
        overloadedMethod _ = layoutXyToIndex

    #endif