{-# 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 (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Pango.Structs.AttrShape
    ( 

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


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

#if defined(ENABLE_OVERLOADING)
    ResolveAttrShapeMethod                  ,
#endif


-- ** new #method:new#

    attrShapeNew                            ,




 -- * 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 @/pango_attr_shape_new_with_data()/@)

#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.ManagedPtr as B.ManagedPtr
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 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 (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 WrappedPtr AttrShape where
    wrappedPtrCalloc :: IO (Ptr AttrShape)
wrappedPtrCalloc = Int -> IO (Ptr AttrShape)
forall a. Int -> IO (Ptr a)
callocBytes 72
    wrappedPtrCopy :: AttrShape -> IO AttrShape
wrappedPtrCopy = \p :: AttrShape
p -> AttrShape -> (Ptr AttrShape -> IO AttrShape) -> IO AttrShape
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AttrShape
p (Int -> Ptr AttrShape -> IO (Ptr AttrShape)
forall a. WrappedPtr 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, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr AttrShape -> AttrShape
AttrShape)
    wrappedPtrFree :: Maybe (GDestroyNotify AttrShape)
wrappedPtrFree = GDestroyNotify AttrShape -> Maybe (GDestroyNotify AttrShape)
forall a. a -> Maybe a
Just GDestroyNotify AttrShape
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | 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. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc 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, WrappedPtr 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


-- | A convenience alias for `Nothing` :: `Maybe` `AttrShape`.
noAttrShape :: Maybe AttrShape
noAttrShape :: Maybe AttrShape
noAttrShape = Maybe AttrShape
forall a. Maybe a
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 :: 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, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr 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, WrappedPtr 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, WrappedPtr 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, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr 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