    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The t'GI.Pango.Structs.AttrShape.AttrShape' structure is used to represent attributes which
    -- impose shape restrictions.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Pango.Structs.AttrShape
        (

    -- * Exported types
        AttrShape(..)                           ,
        newZeroAttrShape                        ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveAttrShapeMethod                  ,
    #endif

    -- ** new #method:new#

        attrShapeNew                            ,

    -- ** newWithData #method:newWithData#

        attrShapeNewWithData                    ,

     -- * Properties
    -- ** attr #attr:attr#
    -- | the common portion of the attribute

    #if defined(ENABLE_OVERLOADING)
        attrShape_attr                          ,
    #endif
        getAttrShapeAttr                        ,

    -- ** copyFunc #attr:copyFunc#
    -- | copy function for the user data

    #if defined(ENABLE_OVERLOADING)
        attrShape_copyFunc                      ,
    #endif
        clearAttrShapeCopyFunc                  ,
        getAttrShapeCopyFunc                    ,
        setAttrShapeCopyFunc                    ,

    -- ** data #attr:data#
    -- | user data set (see 'GI.Pango.Functions.attrShapeNewWithData')

    #if defined(ENABLE_OVERLOADING)
        attrShape_data                          ,
    #endif
        clearAttrShapeData                      ,
        getAttrShapeData                        ,
        setAttrShapeData                        ,

    -- ** destroyFunc #attr:destroyFunc#
    -- | destroy function for the user data

    #if defined(ENABLE_OVERLOADING)
        attrShape_destroyFunc                   ,
    #endif
        clearAttrShapeDestroyFunc               ,
        getAttrShapeDestroyFunc                 ,
        setAttrShapeDestroyFunc                 ,

    -- ** inkRect #attr:inkRect#
    -- | the ink rectangle to restrict to

    #if defined(ENABLE_OVERLOADING)
        attrShape_inkRect                       ,
    #endif
        getAttrShapeInkRect                     ,

    -- ** logicalRect #attr:logicalRect#
    -- | the logical rectangle to restrict to

    #if defined(ENABLE_OVERLOADING)
        attrShape_logicalRect                   ,
    #endif
        getAttrShapeLogicalRect                 ,

        ) where

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

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

    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.Pango.Callbacks as Pango.Callbacks
    import {-# SOURCE #-} qualified GI.Pango.Structs.Attribute as Pango.Attribute
    import {-# SOURCE #-} qualified GI.Pango.Structs.Rectangle as Pango.Rectangle

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

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

    instance BoxedPtr AttrShape where
        boxedPtrCopy :: AttrShape -> IO AttrShape
    boxedPtrCopy = \p :: AttrShape
    p -> AttrShape -> (Ptr AttrShape -> IO AttrShape) -> IO AttrShape
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr AttrShape
    p (Int -> Ptr AttrShape -> IO (Ptr AttrShape)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes 72 (Ptr AttrShape -> IO (Ptr AttrShape))
    -> (Ptr AttrShape -> IO AttrShape) -> Ptr AttrShape -> IO AttrShape
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr AttrShape -> AttrShape)
    -> Ptr AttrShape -> IO AttrShape
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr AttrShape -> AttrShape
    AttrShape)
        boxedPtrFree :: AttrShape -> IO ()
    boxedPtrFree = \x :: AttrShape
    x -> AttrShape -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr AttrShape
    x Ptr AttrShape -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr AttrShape where
        boxedPtrCalloc :: IO (Ptr AttrShape)
    boxedPtrCalloc = Int -> IO (Ptr AttrShape)
    forall a. Int -> IO (Ptr a)
    callocBytes 72

    -- | Construct a `AttrShape` struct initialized to zero.
    newZeroAttrShape :: MonadIO m => m AttrShape
    newZeroAttrShape :: m AttrShape
    newZeroAttrShape = IO AttrShape -> m AttrShape
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO AttrShape -> m AttrShape) -> IO AttrShape -> m AttrShape
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr AttrShape)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr AttrShape)
    -> (Ptr AttrShape -> IO AttrShape) -> IO AttrShape
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr AttrShape -> AttrShape)
    -> Ptr AttrShape -> IO AttrShape
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr AttrShape -> AttrShape
    AttrShape

    instance tag ~ 'AttrSet => Constructible AttrShape tag where
        new :: (ManagedPtr AttrShape -> AttrShape)
    -> [AttrOp AttrShape tag] -> m AttrShape
    new _ attrs :: [AttrOp AttrShape tag]
    attrs = do
            AttrShape
    o <- m AttrShape
    forall (m :: * -> *). MonadIO m => m AttrShape
    newZeroAttrShape
            AttrShape -> [AttrOp AttrShape 'AttrSet] -> m ()
    forall o (m :: * -> *).
    MonadIO m =>
    o -> [AttrOp o 'AttrSet] -> m ()
    GI.Attributes.set AttrShape
    o [AttrOp AttrShape tag]
    [AttrOp AttrShape 'AttrSet]
    attrs
            AttrShape -> m AttrShape
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrShape
    o

    -- | Get the value of the “@attr@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attrShape #attr
    -- @
    getAttrShapeAttr :: MonadIO m => AttrShape -> m Pango.Attribute.Attribute
    getAttrShapeAttr :: AttrShape -> m Attribute
    getAttrShapeAttr s :: AttrShape
    s = IO Attribute -> m Attribute
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Attribute -> m Attribute) -> IO Attribute -> m Attribute
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO Attribute) -> IO Attribute
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO Attribute) -> IO Attribute)
    -> (Ptr AttrShape -> IO Attribute) -> IO Attribute
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        let val :: Ptr Attribute
    val = Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr Attribute
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0 :: (Ptr Pango.Attribute.Attribute)
        Attribute
    val' <- ((ManagedPtr Attribute -> Attribute)
    -> Ptr Attribute -> IO Attribute
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr Attribute -> Attribute
    Pango.Attribute.Attribute) Ptr Attribute
    val
        Attribute -> IO Attribute
    forall (m :: * -> *) a. Monad m => a -> m a
    return Attribute
    val'

    #if defined(ENABLE_OVERLOADING)
    data AttrShapeAttrFieldInfo
    instance AttrInfo AttrShapeAttrFieldInfo where
        type AttrBaseTypeConstraint AttrShapeAttrFieldInfo = (~) AttrShape
        type AttrAllowedOps AttrShapeAttrFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AttrShapeAttrFieldInfo = (~) (Ptr Pango.Attribute.Attribute)
        type AttrTransferTypeConstraint AttrShapeAttrFieldInfo = (~)(Ptr Pango.Attribute.Attribute)
        type AttrTransferType AttrShapeAttrFieldInfo = (Ptr Pango.Attribute.Attribute)
        type AttrGetType AttrShapeAttrFieldInfo = Pango.Attribute.Attribute
        type AttrLabel AttrShapeAttrFieldInfo = "attr"
        type AttrOrigin AttrShapeAttrFieldInfo = AttrShape
        attrGet = getAttrShapeAttr
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined

    attrShape_attr :: AttrLabelProxy "attr"
    attrShape_attr = AttrLabelProxy

    #endif

    -- | Get the value of the “@ink_rect@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attrShape #inkRect
    -- @
    getAttrShapeInkRect :: MonadIO m => AttrShape -> m Pango.Rectangle.Rectangle
    getAttrShapeInkRect :: AttrShape -> m Rectangle
    getAttrShapeInkRect s :: AttrShape
    s = IO Rectangle -> m Rectangle
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO Rectangle) -> IO Rectangle
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO Rectangle) -> IO Rectangle)
    -> (Ptr AttrShape -> IO Rectangle) -> IO Rectangle
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        let val :: Ptr Rectangle
    val = Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr Rectangle
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 16 :: (Ptr Pango.Rectangle.Rectangle)
        Rectangle
    val' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    val
        Rectangle -> IO Rectangle
    forall (m :: * -> *) a. Monad m => a -> m a
    return Rectangle
    val'

    #if defined(ENABLE_OVERLOADING)
    data AttrShapeInkRectFieldInfo
    instance AttrInfo AttrShapeInkRectFieldInfo where
        type AttrBaseTypeConstraint AttrShapeInkRectFieldInfo = (~) AttrShape
        type AttrAllowedOps AttrShapeInkRectFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AttrShapeInkRectFieldInfo = (~) (Ptr Pango.Rectangle.Rectangle)
        type AttrTransferTypeConstraint AttrShapeInkRectFieldInfo = (~)(Ptr Pango.Rectangle.Rectangle)
        type AttrTransferType AttrShapeInkRectFieldInfo = (Ptr Pango.Rectangle.Rectangle)
        type AttrGetType AttrShapeInkRectFieldInfo = Pango.Rectangle.Rectangle
        type AttrLabel AttrShapeInkRectFieldInfo = "ink_rect"
        type AttrOrigin AttrShapeInkRectFieldInfo = AttrShape
        attrGet = getAttrShapeInkRect
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined

    attrShape_inkRect :: AttrLabelProxy "inkRect"
    attrShape_inkRect = AttrLabelProxy

    #endif

    -- | Get the value of the “@logical_rect@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attrShape #logicalRect
    -- @
    getAttrShapeLogicalRect :: MonadIO m => AttrShape -> m Pango.Rectangle.Rectangle
    getAttrShapeLogicalRect :: AttrShape -> m Rectangle
    getAttrShapeLogicalRect s :: AttrShape
    s = IO Rectangle -> m Rectangle
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO Rectangle) -> IO Rectangle
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO Rectangle) -> IO Rectangle)
    -> (Ptr AttrShape -> IO Rectangle) -> IO Rectangle
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        let val :: Ptr Rectangle
    val = Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr Rectangle
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 32 :: (Ptr Pango.Rectangle.Rectangle)
        Rectangle
    val' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    val
        Rectangle -> IO Rectangle
    forall (m :: * -> *) a. Monad m => a -> m a
    return Rectangle
    val'

    #if defined(ENABLE_OVERLOADING)
    data AttrShapeLogicalRectFieldInfo
    instance AttrInfo AttrShapeLogicalRectFieldInfo where
        type AttrBaseTypeConstraint AttrShapeLogicalRectFieldInfo = (~) AttrShape
        type AttrAllowedOps AttrShapeLogicalRectFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AttrShapeLogicalRectFieldInfo = (~) (Ptr Pango.Rectangle.Rectangle)
        type AttrTransferTypeConstraint AttrShapeLogicalRectFieldInfo = (~)(Ptr Pango.Rectangle.Rectangle)
        type AttrTransferType AttrShapeLogicalRectFieldInfo = (Ptr Pango.Rectangle.Rectangle)
        type AttrGetType AttrShapeLogicalRectFieldInfo = Pango.Rectangle.Rectangle
        type AttrLabel AttrShapeLogicalRectFieldInfo = "logical_rect"
        type AttrOrigin AttrShapeLogicalRectFieldInfo = AttrShape
        attrGet = getAttrShapeLogicalRect
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined

    attrShape_logicalRect :: AttrLabelProxy "logicalRect"
    attrShape_logicalRect = AttrLabelProxy

    #endif

    -- | Get the value of the “@data@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attrShape #data
    -- @
    getAttrShapeData :: MonadIO m => AttrShape -> m (Ptr ())
    getAttrShapeData :: AttrShape -> m (Ptr ())
    getAttrShapeData s :: AttrShape
    s = IO (Ptr ()) -> m (Ptr ())
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO (Ptr ())) -> IO (Ptr ())
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO (Ptr ())) -> IO (Ptr ()))
    -> (Ptr AttrShape -> IO (Ptr ())) -> IO (Ptr ())
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        Ptr ()
    val <- Ptr (Ptr ()) -> IO (Ptr ())
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (Ptr ())
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 48) :: IO (Ptr ())
        Ptr () -> IO (Ptr ())
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr ()
    val

    -- | Set the value of the “@data@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' attrShape [ #data 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setAttrShapeData :: MonadIO m => AttrShape -> Ptr () -> m ()
    setAttrShapeData :: AttrShape -> Ptr () -> m ()
    setAttrShapeData s :: AttrShape
    s val :: Ptr ()
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO ()) -> IO ())
    -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        Ptr (Ptr ()) -> Ptr () -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (Ptr ())
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 48) (Ptr ()
    val :: Ptr ())

    -- | Set the value of the “@data@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #data
    -- @
    clearAttrShapeData :: MonadIO m => AttrShape -> m ()
    clearAttrShapeData :: AttrShape -> m ()
    clearAttrShapeData s :: AttrShape
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO ()) -> IO ())
    -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        Ptr (Ptr ()) -> Ptr () -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (Ptr ())
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 48) (Ptr ()
    forall a. Ptr a
    FP.nullPtr :: Ptr ())

    #if defined(ENABLE_OVERLOADING)
    data AttrShapeDataFieldInfo
    instance AttrInfo AttrShapeDataFieldInfo where
        type AttrBaseTypeConstraint AttrShapeDataFieldInfo = (~) AttrShape
        type AttrAllowedOps AttrShapeDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint AttrShapeDataFieldInfo = (~) (Ptr ())
        type AttrTransferTypeConstraint AttrShapeDataFieldInfo = (~)(Ptr ())
        type AttrTransferType AttrShapeDataFieldInfo = (Ptr ())
        type AttrGetType AttrShapeDataFieldInfo = Ptr ()
        type AttrLabel AttrShapeDataFieldInfo = "data"
        type AttrOrigin AttrShapeDataFieldInfo = AttrShape
        attrGet = getAttrShapeData
        attrSet = setAttrShapeData
        attrConstruct = undefined
        attrClear = clearAttrShapeData
        attrTransfer _ v = do
            return v

    attrShape_data :: AttrLabelProxy "data"
    attrShape_data = AttrLabelProxy

    #endif

    -- | Get the value of the “@copy_func@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attrShape #copyFunc
    -- @
    getAttrShapeCopyFunc :: MonadIO m => AttrShape -> m (Maybe Pango.Callbacks.AttrDataCopyFunc_WithClosures)
    getAttrShapeCopyFunc :: AttrShape -> m (Maybe (Ptr () -> IO (Ptr ())))
    getAttrShapeCopyFunc s :: AttrShape
    s = IO (Maybe (Ptr () -> IO (Ptr ())))
    -> m (Maybe (Ptr () -> IO (Ptr ())))
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe (Ptr () -> IO (Ptr ())))
     -> m (Maybe (Ptr () -> IO (Ptr ()))))
    -> IO (Maybe (Ptr () -> IO (Ptr ())))
    -> m (Maybe (Ptr () -> IO (Ptr ())))
    forall a b. (a -> b) -> a -> b
    $ AttrShape
    -> (Ptr AttrShape -> IO (Maybe (Ptr () -> IO (Ptr ()))))
    -> IO (Maybe (Ptr () -> IO (Ptr ())))
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO (Maybe (Ptr () -> IO (Ptr ()))))
     -> IO (Maybe (Ptr () -> IO (Ptr ()))))
    -> (Ptr AttrShape -> IO (Maybe (Ptr () -> IO (Ptr ()))))
    -> IO (Maybe (Ptr () -> IO (Ptr ())))
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        FunPtr (Ptr () -> IO (Ptr ()))
    val <- Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    -> IO (FunPtr (Ptr () -> IO (Ptr ())))
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 56) :: IO (FunPtr Pango.Callbacks.C_AttrDataCopyFunc)
        Maybe (Ptr () -> IO (Ptr ()))
    result <- FunPtr (Ptr () -> IO (Ptr ()))
    -> (FunPtr (Ptr () -> IO (Ptr ())) -> IO (Ptr () -> IO (Ptr ())))
    -> IO (Maybe (Ptr () -> IO (Ptr ())))
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr (Ptr () -> IO (Ptr ()))
    val ((FunPtr (Ptr () -> IO (Ptr ())) -> IO (Ptr () -> IO (Ptr ())))
     -> IO (Maybe (Ptr () -> IO (Ptr ()))))
    -> (FunPtr (Ptr () -> IO (Ptr ())) -> IO (Ptr () -> IO (Ptr ())))
    -> IO (Maybe (Ptr () -> IO (Ptr ())))
    forall a b. (a -> b) -> a -> b
    $ \val' :: FunPtr (Ptr () -> IO (Ptr ()))
    val' -> do
            let val'' :: Ptr () -> IO (Ptr ())
    val'' = FunPtr (Ptr () -> IO (Ptr ())) -> Ptr () -> IO (Ptr ())
    forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr (Ptr () -> IO (Ptr ())) -> Ptr () -> m (Ptr ())
    Pango.Callbacks.dynamic_AttrDataCopyFunc FunPtr (Ptr () -> IO (Ptr ()))
    val'
            (Ptr () -> IO (Ptr ())) -> IO (Ptr () -> IO (Ptr ()))
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr () -> IO (Ptr ())
    val''
        Maybe (Ptr () -> IO (Ptr ())) -> IO (Maybe (Ptr () -> IO (Ptr ())))
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Ptr () -> IO (Ptr ()))
    result

    -- | Set the value of the “@copy_func@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' attrShape [ #copyFunc 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setAttrShapeCopyFunc :: MonadIO m => AttrShape -> FunPtr Pango.Callbacks.C_AttrDataCopyFunc -> m ()
    setAttrShapeCopyFunc :: AttrShape -> FunPtr (Ptr () -> IO (Ptr ())) -> m ()
    setAttrShapeCopyFunc s :: AttrShape
    s val :: FunPtr (Ptr () -> IO (Ptr ()))
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO ()) -> IO ())
    -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    -> FunPtr (Ptr () -> IO (Ptr ())) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 56) (FunPtr (Ptr () -> IO (Ptr ()))
    val :: FunPtr Pango.Callbacks.C_AttrDataCopyFunc)

    -- | Set the value of the “@copy_func@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #copyFunc
    -- @
    clearAttrShapeCopyFunc :: MonadIO m => AttrShape -> m ()
    clearAttrShapeCopyFunc :: AttrShape -> m ()
    clearAttrShapeCopyFunc s :: AttrShape
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO ()) -> IO ())
    -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    -> FunPtr (Ptr () -> IO (Ptr ())) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (FunPtr (Ptr () -> IO (Ptr ())))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 56) (FunPtr (Ptr () -> IO (Ptr ()))
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Pango.Callbacks.C_AttrDataCopyFunc)

    #if defined(ENABLE_OVERLOADING)
    data AttrShapeCopyFuncFieldInfo
    instance AttrInfo AttrShapeCopyFuncFieldInfo where
        type AttrBaseTypeConstraint AttrShapeCopyFuncFieldInfo = (~) AttrShape
        type AttrAllowedOps AttrShapeCopyFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint AttrShapeCopyFuncFieldInfo = (~) (FunPtr Pango.Callbacks.C_AttrDataCopyFunc)
        type AttrTransferTypeConstraint AttrShapeCopyFuncFieldInfo = (~)Pango.Callbacks.AttrDataCopyFunc_WithClosures
        type AttrTransferType AttrShapeCopyFuncFieldInfo = (FunPtr Pango.Callbacks.C_AttrDataCopyFunc)
        type AttrGetType AttrShapeCopyFuncFieldInfo = Maybe Pango.Callbacks.AttrDataCopyFunc_WithClosures
        type AttrLabel AttrShapeCopyFuncFieldInfo = "copy_func"
        type AttrOrigin AttrShapeCopyFuncFieldInfo = AttrShape
        attrGet = getAttrShapeCopyFunc
        attrSet = setAttrShapeCopyFunc
        attrConstruct = undefined
        attrClear = clearAttrShapeCopyFunc
        attrTransfer _ v = do
            Pango.Callbacks.mk_AttrDataCopyFunc (Pango.Callbacks.wrap_AttrDataCopyFunc Nothing v)

    attrShape_copyFunc :: AttrLabelProxy "copyFunc"
    attrShape_copyFunc = AttrLabelProxy

    #endif

    -- | Get the value of the “@destroy_func@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attrShape #destroyFunc
    -- @
    getAttrShapeDestroyFunc :: MonadIO m => AttrShape -> m (Maybe GLib.Callbacks.DestroyNotify)
    getAttrShapeDestroyFunc :: AttrShape -> m (Maybe (Ptr () -> IO ()))
    getAttrShapeDestroyFunc s :: AttrShape
    s = IO (Maybe (Ptr () -> IO ())) -> m (Maybe (Ptr () -> IO ()))
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe (Ptr () -> IO ())) -> m (Maybe (Ptr () -> IO ())))
    -> IO (Maybe (Ptr () -> IO ())) -> m (Maybe (Ptr () -> IO ()))
    forall a b. (a -> b) -> a -> b
    $ AttrShape
    -> (Ptr AttrShape -> IO (Maybe (Ptr () -> IO ())))
    -> IO (Maybe (Ptr () -> IO ()))
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO (Maybe (Ptr () -> IO ())))
     -> IO (Maybe (Ptr () -> IO ())))
    -> (Ptr AttrShape -> IO (Maybe (Ptr () -> IO ())))
    -> IO (Maybe (Ptr () -> IO ()))
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        FunPtr (Ptr () -> IO ())
    val <- Ptr (FunPtr (Ptr () -> IO ())) -> IO (FunPtr (Ptr () -> IO ()))
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (FunPtr (Ptr () -> IO ()))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 64) :: IO (FunPtr GLib.Callbacks.C_DestroyNotify)
        Maybe (Ptr () -> IO ())
    result <- FunPtr (Ptr () -> IO ())
    -> (FunPtr (Ptr () -> IO ()) -> IO (Ptr () -> IO ()))
    -> IO (Maybe (Ptr () -> IO ()))
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr (Ptr () -> IO ())
    val ((FunPtr (Ptr () -> IO ()) -> IO (Ptr () -> IO ()))
     -> IO (Maybe (Ptr () -> IO ())))
    -> (FunPtr (Ptr () -> IO ()) -> IO (Ptr () -> IO ()))
    -> IO (Maybe (Ptr () -> IO ()))
    forall a b. (a -> b) -> a -> b
    $ \val' :: FunPtr (Ptr () -> IO ())
    val' -> do
            let val'' :: Ptr () -> IO ()
    val'' = FunPtr (Ptr () -> IO ()) -> Ptr () -> IO ()
    forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr (Ptr () -> IO ()) -> Ptr () -> m ()
    GLib.Callbacks.dynamic_DestroyNotify FunPtr (Ptr () -> IO ())
    val'
            (Ptr () -> IO ()) -> IO (Ptr () -> IO ())
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr () -> IO ()
    val''
        Maybe (Ptr () -> IO ()) -> IO (Maybe (Ptr () -> IO ()))
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Ptr () -> IO ())
    result

    -- | Set the value of the “@destroy_func@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' attrShape [ #destroyFunc 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setAttrShapeDestroyFunc :: MonadIO m => AttrShape -> FunPtr GLib.Callbacks.C_DestroyNotify -> m ()
    setAttrShapeDestroyFunc :: AttrShape -> FunPtr (Ptr () -> IO ()) -> m ()
    setAttrShapeDestroyFunc s :: AttrShape
    s val :: FunPtr (Ptr () -> IO ())
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO ()) -> IO ())
    -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        Ptr (FunPtr (Ptr () -> IO ())) -> FunPtr (Ptr () -> IO ()) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (FunPtr (Ptr () -> IO ()))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 64) (FunPtr (Ptr () -> IO ())
    val :: FunPtr GLib.Callbacks.C_DestroyNotify)

    -- | Set the value of the “@destroy_func@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #destroyFunc
    -- @
    clearAttrShapeDestroyFunc :: MonadIO m => AttrShape -> m ()
    clearAttrShapeDestroyFunc :: AttrShape -> m ()
    clearAttrShapeDestroyFunc s :: AttrShape
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ AttrShape -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrShape
    s ((Ptr AttrShape -> IO ()) -> IO ())
    -> (Ptr AttrShape -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr AttrShape
    ptr -> do
        Ptr (FunPtr (Ptr () -> IO ())) -> FunPtr (Ptr () -> IO ()) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr AttrShape
    ptr Ptr AttrShape -> Int -> Ptr (FunPtr (Ptr () -> IO ()))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 64) (FunPtr (Ptr () -> IO ())
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr GLib.Callbacks.C_DestroyNotify)

    #if defined(ENABLE_OVERLOADING)
    data AttrShapeDestroyFuncFieldInfo
    instance AttrInfo AttrShapeDestroyFuncFieldInfo where
        type AttrBaseTypeConstraint AttrShapeDestroyFuncFieldInfo = (~) AttrShape
        type AttrAllowedOps AttrShapeDestroyFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint AttrShapeDestroyFuncFieldInfo = (~) (FunPtr GLib.Callbacks.C_DestroyNotify)
        type AttrTransferTypeConstraint AttrShapeDestroyFuncFieldInfo = (~)GLib.Callbacks.DestroyNotify
        type AttrTransferType AttrShapeDestroyFuncFieldInfo = (FunPtr GLib.Callbacks.C_DestroyNotify)
        type AttrGetType AttrShapeDestroyFuncFieldInfo = Maybe GLib.Callbacks.DestroyNotify
        type AttrLabel AttrShapeDestroyFuncFieldInfo = "destroy_func"
        type AttrOrigin AttrShapeDestroyFuncFieldInfo = AttrShape
        attrGet = getAttrShapeDestroyFunc
        attrSet = setAttrShapeDestroyFunc
        attrConstruct = undefined
        attrClear = clearAttrShapeDestroyFunc
        attrTransfer _ v = do
            GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify Nothing v)

    attrShape_destroyFunc :: AttrLabelProxy "destroyFunc"
    attrShape_destroyFunc = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList AttrShape
    type instance O.AttributeList AttrShape = AttrShapeAttributeList
    type AttrShapeAttributeList = ('[ '("attr", AttrShapeAttrFieldInfo), '("inkRect", AttrShapeInkRectFieldInfo), '("logicalRect", AttrShapeLogicalRectFieldInfo), '("data", AttrShapeDataFieldInfo), '("copyFunc", AttrShapeCopyFuncFieldInfo), '("destroyFunc", AttrShapeDestroyFuncFieldInfo)] :: [(Symbol, *)])
    #endif

    -- method AttrShape::new
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "ink_rect"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Rectangle" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "ink rectangle to assign to each character"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "logical_rect"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Rectangle" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "logical rectangle to assign to each character"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Attribute" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attr_shape_new" pango_attr_shape_new ::
        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 (Ptr Pango.Attribute.Attribute)

    -- | Create a new shape attribute. A shape is used to impose a
    -- particular ink and logical rectangle on the result of shaping a
    -- particular glyph. This might be used, for instance, for
    -- embedding a picture or a widget inside a t'GI.Pango.Objects.Layout.Layout'.
    attrShapeNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Pango.Rectangle.Rectangle
        -- ^ /@inkRect@/: ink rectangle to assign to each character
        -> Pango.Rectangle.Rectangle
        -- ^ /@logicalRect@/: logical rectangle to assign to each character
        -> m Pango.Attribute.Attribute
        -- ^ __Returns:__ the newly allocated t'GI.Pango.Structs.Attribute.Attribute',
        --               which should be freed with 'GI.Pango.Structs.Attribute.attributeDestroy'.
    attrShapeNew :: Rectangle -> Rectangle -> m Attribute
    attrShapeNew inkRect :: Rectangle
    inkRect logicalRect :: Rectangle
    logicalRect = IO Attribute -> m Attribute
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Attribute -> m Attribute) -> IO Attribute -> m Attribute
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Rectangle
    inkRect' <- Rectangle -> IO (Ptr Rectangle)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Rectangle
    inkRect
        Ptr Rectangle
    logicalRect' <- Rectangle -> IO (Ptr Rectangle)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Rectangle
    logicalRect
        Ptr Attribute
    result <- Ptr Rectangle -> Ptr Rectangle -> IO (Ptr Attribute)
    pango_attr_shape_new Ptr Rectangle
    inkRect' Ptr Rectangle
    logicalRect'
        Text -> Ptr Attribute -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "attrShapeNew" Ptr Attribute
    result
        Attribute
    result' <- ((ManagedPtr Attribute -> Attribute)
    -> Ptr Attribute -> IO Attribute
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Attribute -> Attribute
    Pango.Attribute.Attribute) Ptr Attribute
    result
        Rectangle -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Rectangle
    inkRect
        Rectangle -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Rectangle
    logicalRect
        Attribute -> IO Attribute
    forall (m :: * -> *) a. Monad m => a -> m a
    return Attribute
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method AttrShape::new_with_data
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "ink_rect"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Rectangle" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "ink rectangle to assign to each character"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "logical_rect"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Rectangle" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "logical rectangle to assign to each character"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "data"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "user data pointer" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "copy_func"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "AttrDataCopyFunc" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "function to copy @data when the\n               attribute is copied. If %NULL, @data is simply\n               copied as a pointer."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeNotified
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "destroy_func"
    --           , argType =
    --               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "function to free @data when the\n               attribute is freed, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Attribute" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attr_shape_new_with_data" pango_attr_shape_new_with_data ::
        Ptr Pango.Rectangle.Rectangle ->        -- ink_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        Ptr Pango.Rectangle.Rectangle ->        -- logical_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        Ptr () ->                               -- data : TBasicType TPtr
        FunPtr Pango.Callbacks.C_AttrDataCopyFunc -> -- copy_func : TInterface (Name {namespace = "Pango", name = "AttrDataCopyFunc"})
        FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
        IO (Ptr Pango.Attribute.Attribute)

    -- | Like 'GI.Pango.Functions.attrShapeNew', but a user data pointer is also
    -- provided; this pointer can be accessed when later
    -- rendering the glyph.
    --
    -- /Since: 1.8/
    attrShapeNewWithData ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Pango.Rectangle.Rectangle
        -- ^ /@inkRect@/: ink rectangle to assign to each character
        -> Pango.Rectangle.Rectangle
        -- ^ /@logicalRect@/: logical rectangle to assign to each character
        -> Ptr ()
        -- ^ /@data@/: user data pointer
        -> Maybe (Pango.Callbacks.AttrDataCopyFunc)
        -- ^ /@copyFunc@/: function to copy /@data@/ when the
        --                attribute is copied. If 'P.Nothing', /@data@/ is simply
        --                copied as a pointer.
        -> Maybe (GLib.Callbacks.DestroyNotify)
        -- ^ /@destroyFunc@/: function to free /@data@/ when the
        --                attribute is freed, or 'P.Nothing'
        -> m Pango.Attribute.Attribute
        -- ^ __Returns:__ the newly allocated t'GI.Pango.Structs.Attribute.Attribute', which should be
        --               freed with 'GI.Pango.Structs.Attribute.attributeDestroy'.
    attrShapeNewWithData :: Rectangle
    -> Rectangle
    -> Ptr ()
    -> Maybe (IO (Ptr ()))
    -> Maybe (Ptr () -> IO ())
    -> m Attribute
    attrShapeNewWithData inkRect :: Rectangle
    inkRect logicalRect :: Rectangle
    logicalRect data_ :: Ptr ()
    data_ copyFunc :: Maybe (IO (Ptr ()))
    copyFunc destroyFunc :: Maybe (Ptr () -> IO ())
    destroyFunc = IO Attribute -> m Attribute
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Attribute -> m Attribute) -> IO Attribute -> m Attribute
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Rectangle
    inkRect' <- Rectangle -> IO (Ptr Rectangle)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Rectangle
    inkRect
        Ptr Rectangle
    logicalRect' <- Rectangle -> IO (Ptr Rectangle)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Rectangle
    logicalRect
        FunPtr (Ptr () -> IO (Ptr ()))
    maybeCopyFunc <- case Maybe (IO (Ptr ()))
    copyFunc of
            Nothing -> FunPtr (Ptr () -> IO (Ptr ()))
    -> IO (FunPtr (Ptr () -> IO (Ptr ())))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Ptr Any -> FunPtr (Ptr () -> IO (Ptr ()))
    forall a b. Ptr a -> FunPtr b
    castPtrToFunPtr Ptr Any
    forall a. Ptr a
    nullPtr)
            Just jCopyFunc :: IO (Ptr ())
    jCopyFunc -> do
                FunPtr (Ptr () -> IO (Ptr ()))
    jCopyFunc' <- (Ptr () -> IO (Ptr ())) -> IO (FunPtr (Ptr () -> IO (Ptr ())))
    Pango.Callbacks.mk_AttrDataCopyFunc (Maybe (Ptr (FunPtr (Ptr () -> IO (Ptr ()))))
    -> (Ptr () -> IO (Ptr ())) -> Ptr () -> IO (Ptr ())
    Pango.Callbacks.wrap_AttrDataCopyFunc Maybe (Ptr (FunPtr (Ptr () -> IO (Ptr ()))))
    forall a. Maybe a
    Nothing (IO (Ptr ()) -> Ptr () -> IO (Ptr ())
    Pango.Callbacks.drop_closures_AttrDataCopyFunc IO (Ptr ())
    jCopyFunc))
                FunPtr (Ptr () -> IO (Ptr ()))
    -> IO (FunPtr (Ptr () -> IO (Ptr ())))
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr (Ptr () -> IO (Ptr ()))
    jCopyFunc'
        FunPtr (Ptr () -> IO ())
    maybeDestroyFunc <- case Maybe (Ptr () -> IO ())
    destroyFunc of
            Nothing -> FunPtr (Ptr () -> IO ()) -> IO (FunPtr (Ptr () -> IO ()))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Ptr Any -> FunPtr (Ptr () -> IO ())
    forall a b. Ptr a -> FunPtr b
    castPtrToFunPtr Ptr Any
    forall a. Ptr a
    nullPtr)
            Just jDestroyFunc :: Ptr () -> IO ()
    jDestroyFunc -> do
                Ptr (FunPtr (Ptr () -> IO ()))
    ptrdestroyFunc <- IO (Ptr (FunPtr (Ptr () -> IO ())))
    forall a. Storable a => IO (Ptr a)
    callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
                FunPtr (Ptr () -> IO ())
    jDestroyFunc' <- (Ptr () -> IO ()) -> IO (FunPtr (Ptr () -> IO ()))
    GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr (Ptr () -> IO ())))
    -> (Ptr () -> IO ()) -> Ptr () -> IO ()
    GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr (Ptr () -> IO ()))
    -> Maybe (Ptr (FunPtr (Ptr () -> IO ())))
    forall a. a -> Maybe a
    Just Ptr (FunPtr (Ptr () -> IO ()))
    ptrdestroyFunc) Ptr () -> IO ()
    jDestroyFunc)
                Ptr (FunPtr (Ptr () -> IO ())) -> FunPtr (Ptr () -> IO ()) -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke Ptr (FunPtr (Ptr () -> IO ()))
    ptrdestroyFunc FunPtr (Ptr () -> IO ())
    jDestroyFunc'
                FunPtr (Ptr () -> IO ()) -> IO (FunPtr (Ptr () -> IO ()))
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr (Ptr () -> IO ())
    jDestroyFunc'
        Ptr Attribute
    result <- Ptr Rectangle
    -> Ptr Rectangle
    -> Ptr ()
    -> FunPtr (Ptr () -> IO (Ptr ()))
    -> FunPtr (Ptr () -> IO ())
    -> IO (Ptr Attribute)
    pango_attr_shape_new_with_data Ptr Rectangle
    inkRect' Ptr Rectangle
    logicalRect' Ptr ()
    data_ FunPtr (Ptr () -> IO (Ptr ()))
    maybeCopyFunc FunPtr (Ptr () -> IO ())
    maybeDestroyFunc
        Text -> Ptr Attribute -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "attrShapeNewWithData" Ptr Attribute
    result
        Attribute
    result' <- ((ManagedPtr Attribute -> Attribute)
    -> Ptr Attribute -> IO Attribute
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Attribute -> Attribute
    Pango.Attribute.Attribute) Ptr Attribute
    result
        Rectangle -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Rectangle
    inkRect
        Rectangle -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Rectangle
    logicalRect
        Attribute -> IO Attribute
    forall (m :: * -> *) a. Monad m => a -> m a
    return Attribute
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveAttrShapeMethod (t :: Symbol) (o :: *) :: * where
        ResolveAttrShapeMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveAttrShapeMethod t AttrShape, O.MethodInfo info AttrShape p) => OL.IsLabel t (AttrShape -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #endif