{- |
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 (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !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