    {- |
    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.Structs.AttrShape.AttrShape' structure is used to represent attributes which
    impose shape restrictions.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Pango.Structs.AttrShape
        (

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

     -- * Methods
    -- ** new #method:new#

        attrShapeNew                            ,

     -- * Properties
    -- ** attr #attr:attr#
    {- | the common portion of the attribute
    -}
    #if ENABLE_OVERLOADING
        attrShape_attr                          ,
    #endif
        getAttrShapeAttr                        ,

    -- ** copyFunc #attr:copyFunc#
    {- | copy function for the user data
    -}
    #if ENABLE_OVERLOADING
        attrShape_copyFunc                      ,
    #endif
        clearAttrShapeCopyFunc                  ,
        getAttrShapeCopyFunc                    ,
        setAttrShapeCopyFunc                    ,

    -- ** data #attr:data#
    {- | user data set (see @/pango_attr_shape_new_with_data()/@)
    -}
    #if ENABLE_OVERLOADING
        attrShape_data                          ,
    #endif
        clearAttrShapeData                      ,
        getAttrShapeData                        ,
        setAttrShapeData                        ,

    -- ** destroyFunc #attr:destroyFunc#
    {- | destroy function for the user data
    -}
    #if ENABLE_OVERLOADING
        attrShape_destroyFunc                   ,
    #endif
        clearAttrShapeDestroyFunc               ,
        getAttrShapeDestroyFunc                 ,
        setAttrShapeDestroyFunc                 ,

    -- ** inkRect #attr:inkRect#
    {- | the ink rectangle to restrict to
    -}
    #if ENABLE_OVERLOADING
        attrShape_inkRect                       ,
    #endif
        getAttrShapeInkRect                     ,

    -- ** logicalRect #attr:logicalRect#
    {- | the logical rectangle to restrict to
    -}
    #if 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.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.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 (ManagedPtr AttrShape)
    instance WrappedPtr AttrShape where
        wrappedPtrCalloc = callocBytes 72
        wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 72 >=> wrapPtr AttrShape)
        wrappedPtrFree = Just ptr_to_g_free

    -- | Construct a `AttrShape` struct initialized to zero.
    newZeroAttrShape :: MonadIO m => m AttrShape
    newZeroAttrShape = liftIO $ wrappedPtrCalloc >>= wrapPtr AttrShape

    instance tag ~ 'AttrSet => Constructible AttrShape tag where
        new _ attrs = do
            o <- newZeroAttrShape
            GI.Attributes.set o attrs
            return o

    -- | A convenience alias for `Nothing` :: `Maybe` `AttrShape`.
    noAttrShape :: Maybe AttrShape
    noAttrShape = Nothing

    {- |
    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 s = liftIO $ withManagedPtr s $ \ptr -> do
        let val = ptr `plusPtr` 0 :: (Ptr Pango.Attribute.Attribute)
        val' <- (newPtr Pango.Attribute.Attribute) val
        return val'

    #if ENABLE_OVERLOADING
    data AttrShapeAttrFieldInfo
    instance AttrInfo AttrShapeAttrFieldInfo where
        type AttrAllowedOps AttrShapeAttrFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AttrShapeAttrFieldInfo = (~) (Ptr Pango.Attribute.Attribute)
        type AttrBaseTypeConstraint AttrShapeAttrFieldInfo = (~) AttrShape
        type AttrGetType AttrShapeAttrFieldInfo = Pango.Attribute.Attribute
        type AttrLabel AttrShapeAttrFieldInfo = "attr"
        type AttrOrigin AttrShapeAttrFieldInfo = AttrShape
        attrGet _ = getAttrShapeAttr
        attrSet _ = undefined
        attrConstruct = undefined
        attrClear _ = 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 s = liftIO $ withManagedPtr s $ \ptr -> do
        let val = ptr `plusPtr` 16 :: (Ptr Pango.Rectangle.Rectangle)
        val' <- (newPtr Pango.Rectangle.Rectangle) val
        return val'

    #if ENABLE_OVERLOADING
    data AttrShapeInkRectFieldInfo
    instance AttrInfo AttrShapeInkRectFieldInfo where
        type AttrAllowedOps AttrShapeInkRectFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AttrShapeInkRectFieldInfo = (~) (Ptr Pango.Rectangle.Rectangle)
        type AttrBaseTypeConstraint AttrShapeInkRectFieldInfo = (~) AttrShape
        type AttrGetType AttrShapeInkRectFieldInfo = Pango.Rectangle.Rectangle
        type AttrLabel AttrShapeInkRectFieldInfo = "ink_rect"
        type AttrOrigin AttrShapeInkRectFieldInfo = AttrShape
        attrGet _ = getAttrShapeInkRect
        attrSet _ = undefined
        attrConstruct = undefined
        attrClear _ = 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 s = liftIO $ withManagedPtr s $ \ptr -> do
        let val = ptr `plusPtr` 32 :: (Ptr Pango.Rectangle.Rectangle)
        val' <- (newPtr Pango.Rectangle.Rectangle) val
        return val'

    #if ENABLE_OVERLOADING
    data AttrShapeLogicalRectFieldInfo
    instance AttrInfo AttrShapeLogicalRectFieldInfo where
        type AttrAllowedOps AttrShapeLogicalRectFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AttrShapeLogicalRectFieldInfo = (~) (Ptr Pango.Rectangle.Rectangle)
        type AttrBaseTypeConstraint AttrShapeLogicalRectFieldInfo = (~) AttrShape
        type AttrGetType AttrShapeLogicalRectFieldInfo = Pango.Rectangle.Rectangle
        type AttrLabel AttrShapeLogicalRectFieldInfo = "logical_rect"
        type AttrOrigin AttrShapeLogicalRectFieldInfo = AttrShape
        attrGet _ = getAttrShapeLogicalRect
        attrSet _ = undefined
        attrConstruct = undefined
        attrClear _ = 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 s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 48) :: IO (Ptr ())
        return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 48) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 48) (FP.nullPtr :: Ptr ())

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

    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 s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 56) :: IO (FunPtr Pango.Callbacks.C_AttrDataCopyFunc)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = Pango.Callbacks.dynamic_AttrDataCopyFunc val'
            return val''
        return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 56) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 56) (FP.nullFunPtr :: FunPtr Pango.Callbacks.C_AttrDataCopyFunc)

    #if ENABLE_OVERLOADING
    data AttrShapeCopyFuncFieldInfo
    instance AttrInfo AttrShapeCopyFuncFieldInfo where
        type AttrAllowedOps AttrShapeCopyFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint AttrShapeCopyFuncFieldInfo = (~) (FunPtr Pango.Callbacks.C_AttrDataCopyFunc)
        type AttrBaseTypeConstraint AttrShapeCopyFuncFieldInfo = (~) AttrShape
        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

    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 s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 64) :: IO (FunPtr GLib.Callbacks.C_DestroyNotify)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = GLib.Callbacks.dynamic_DestroyNotify val'
            return val''
        return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 64) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 64) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_DestroyNotify)

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

    attrShape_destroyFunc :: AttrLabelProxy "destroyFunc"
    attrShape_destroyFunc = AttrLabelProxy

    #endif

    #if 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 '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 'GI.Pango.Structs.Attribute.Attribute',
                  which should be freed with 'GI.Pango.Structs.Attribute.attributeDestroy'. -}
    attrShapeNew inkRect logicalRect = liftIO $ do
        inkRect' <- unsafeManagedPtrGetPtr inkRect
        logicalRect' <- unsafeManagedPtrGetPtr logicalRect
        result <- pango_attr_shape_new inkRect' logicalRect'
        checkUnexpectedReturnNULL "attrShapeNew" result
        result' <- (wrapPtr Pango.Attribute.Attribute) result
        touchManagedPtr inkRect
        touchManagedPtr logicalRect
        return result'

    #if ENABLE_OVERLOADING
    #endif

    #if 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) => O.IsLabelProxy t (AttrShape -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveAttrShapeMethod t AttrShape, O.MethodInfo info AttrShape p) => O.IsLabel t (AttrShape -> 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