#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Pango.Callbacks
(
AttrClassCopyFieldCallback ,
C_AttrClassCopyFieldCallback ,
dynamic_AttrClassCopyFieldCallback ,
genClosure_AttrClassCopyFieldCallback ,
mk_AttrClassCopyFieldCallback ,
noAttrClassCopyFieldCallback ,
wrap_AttrClassCopyFieldCallback ,
AttrClassDestroyFieldCallback ,
C_AttrClassDestroyFieldCallback ,
dynamic_AttrClassDestroyFieldCallback ,
genClosure_AttrClassDestroyFieldCallback,
mk_AttrClassDestroyFieldCallback ,
noAttrClassDestroyFieldCallback ,
wrap_AttrClassDestroyFieldCallback ,
AttrClassEqualFieldCallback ,
C_AttrClassEqualFieldCallback ,
dynamic_AttrClassEqualFieldCallback ,
genClosure_AttrClassEqualFieldCallback ,
mk_AttrClassEqualFieldCallback ,
noAttrClassEqualFieldCallback ,
wrap_AttrClassEqualFieldCallback ,
AttrDataCopyFunc ,
AttrDataCopyFunc_WithClosures ,
C_AttrDataCopyFunc ,
drop_closures_AttrDataCopyFunc ,
dynamic_AttrDataCopyFunc ,
genClosure_AttrDataCopyFunc ,
mk_AttrDataCopyFunc ,
noAttrDataCopyFunc ,
noAttrDataCopyFunc_WithClosures ,
wrap_AttrDataCopyFunc ,
AttrFilterFunc ,
AttrFilterFunc_WithClosures ,
C_AttrFilterFunc ,
drop_closures_AttrFilterFunc ,
dynamic_AttrFilterFunc ,
genClosure_AttrFilterFunc ,
mk_AttrFilterFunc ,
noAttrFilterFunc ,
noAttrFilterFunc_WithClosures ,
wrap_AttrFilterFunc ,
C_FontsetForeachFunc ,
FontsetForeachFunc ,
FontsetForeachFunc_WithClosures ,
drop_closures_FontsetForeachFunc ,
dynamic_FontsetForeachFunc ,
genClosure_FontsetForeachFunc ,
mk_FontsetForeachFunc ,
noFontsetForeachFunc ,
noFontsetForeachFunc_WithClosures ,
wrap_FontsetForeachFunc ,
) 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.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import {-# SOURCE #-} qualified GI.Pango.Objects.Font as Pango.Font
import {-# SOURCE #-} qualified GI.Pango.Objects.Fontset as Pango.Fontset
import {-# SOURCE #-} qualified GI.Pango.Structs.Attribute as Pango.Attribute
type C_FontsetForeachFunc =
Ptr Pango.Fontset.Fontset ->
Ptr Pango.Font.Font ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_FontsetForeachFunc :: FunPtr C_FontsetForeachFunc -> C_FontsetForeachFunc
dynamic_FontsetForeachFunc ::
(B.CallStack.HasCallStack, MonadIO m, Pango.Fontset.IsFontset a, Pango.Font.IsFont b) =>
FunPtr C_FontsetForeachFunc
-> a
-> b
-> Ptr ()
-> m Bool
dynamic_FontsetForeachFunc :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFontset a, IsFont b) =>
FunPtr C_FontsetForeachFunc -> a -> b -> Ptr () -> m Bool
dynamic_FontsetForeachFunc FunPtr C_FontsetForeachFunc
__funPtr a
fontset b
font Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Fontset
fontset' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontset
Ptr Font
font' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
font
CInt
result <- (FunPtr C_FontsetForeachFunc -> C_FontsetForeachFunc
__dynamic_C_FontsetForeachFunc FunPtr C_FontsetForeachFunc
__funPtr) Ptr Fontset
fontset' Ptr Font
font' Ptr ()
userData
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
fontset
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
font
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_FontsetForeachFunc :: C_FontsetForeachFunc -> IO (FunPtr C_FontsetForeachFunc)
type FontsetForeachFunc =
Pango.Fontset.Fontset
-> Pango.Font.Font
-> IO Bool
noFontsetForeachFunc :: Maybe FontsetForeachFunc
noFontsetForeachFunc :: Maybe FontsetForeachFunc
noFontsetForeachFunc = forall a. Maybe a
Nothing
type FontsetForeachFunc_WithClosures =
Pango.Fontset.Fontset
-> Pango.Font.Font
-> Ptr ()
-> IO Bool
noFontsetForeachFunc_WithClosures :: Maybe FontsetForeachFunc_WithClosures
noFontsetForeachFunc_WithClosures :: Maybe FontsetForeachFunc_WithClosures
noFontsetForeachFunc_WithClosures = forall a. Maybe a
Nothing
drop_closures_FontsetForeachFunc :: FontsetForeachFunc -> FontsetForeachFunc_WithClosures
drop_closures_FontsetForeachFunc :: FontsetForeachFunc -> FontsetForeachFunc_WithClosures
drop_closures_FontsetForeachFunc FontsetForeachFunc
_f Fontset
fontset Font
font Ptr ()
_ = FontsetForeachFunc
_f Fontset
fontset Font
font
genClosure_FontsetForeachFunc :: MonadIO m => FontsetForeachFunc -> m (GClosure C_FontsetForeachFunc)
genClosure_FontsetForeachFunc :: forall (m :: * -> *).
MonadIO m =>
FontsetForeachFunc -> m (GClosure C_FontsetForeachFunc)
genClosure_FontsetForeachFunc FontsetForeachFunc
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: FontsetForeachFunc_WithClosures
cb' = FontsetForeachFunc -> FontsetForeachFunc_WithClosures
drop_closures_FontsetForeachFunc FontsetForeachFunc
cb
let cb'' :: C_FontsetForeachFunc
cb'' = Maybe (Ptr (FunPtr C_FontsetForeachFunc))
-> FontsetForeachFunc_WithClosures -> C_FontsetForeachFunc
wrap_FontsetForeachFunc forall a. Maybe a
Nothing FontsetForeachFunc_WithClosures
cb'
C_FontsetForeachFunc -> IO (FunPtr C_FontsetForeachFunc)
mk_FontsetForeachFunc C_FontsetForeachFunc
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_FontsetForeachFunc ::
Maybe (Ptr (FunPtr C_FontsetForeachFunc)) ->
FontsetForeachFunc_WithClosures ->
C_FontsetForeachFunc
wrap_FontsetForeachFunc :: Maybe (Ptr (FunPtr C_FontsetForeachFunc))
-> FontsetForeachFunc_WithClosures -> C_FontsetForeachFunc
wrap_FontsetForeachFunc Maybe (Ptr (FunPtr C_FontsetForeachFunc))
gi'funptrptr FontsetForeachFunc_WithClosures
gi'cb Ptr Fontset
fontset Ptr Font
font Ptr ()
userData = do
Fontset
fontset' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Fontset -> Fontset
Pango.Fontset.Fontset) Ptr Fontset
fontset
Font
font' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Font -> Font
Pango.Font.Font) Ptr Font
font
Bool
result <- FontsetForeachFunc_WithClosures
gi'cb Fontset
fontset' Font
font' Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_FontsetForeachFunc))
gi'funptrptr
let result' :: CInt
result' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
result
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_AttrFilterFunc =
Ptr Pango.Attribute.Attribute ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_AttrFilterFunc :: FunPtr C_AttrFilterFunc -> C_AttrFilterFunc
dynamic_AttrFilterFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_AttrFilterFunc
-> Pango.Attribute.Attribute
-> Ptr ()
-> m Bool
dynamic_AttrFilterFunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_AttrFilterFunc -> Attribute -> Ptr () -> m Bool
dynamic_AttrFilterFunc FunPtr C_AttrFilterFunc
__funPtr Attribute
attribute Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attribute' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attribute
CInt
result <- (FunPtr C_AttrFilterFunc -> C_AttrFilterFunc
__dynamic_C_AttrFilterFunc FunPtr C_AttrFilterFunc
__funPtr) Ptr Attribute
attribute' Ptr ()
userData
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attribute
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_AttrFilterFunc :: C_AttrFilterFunc -> IO (FunPtr C_AttrFilterFunc)
type AttrFilterFunc =
Pango.Attribute.Attribute
-> IO Bool
noAttrFilterFunc :: Maybe AttrFilterFunc
noAttrFilterFunc :: Maybe AttrFilterFunc
noAttrFilterFunc = forall a. Maybe a
Nothing
type AttrFilterFunc_WithClosures =
Pango.Attribute.Attribute
-> Ptr ()
-> IO Bool
noAttrFilterFunc_WithClosures :: Maybe AttrFilterFunc_WithClosures
noAttrFilterFunc_WithClosures :: Maybe AttrFilterFunc_WithClosures
noAttrFilterFunc_WithClosures = forall a. Maybe a
Nothing
drop_closures_AttrFilterFunc :: AttrFilterFunc -> AttrFilterFunc_WithClosures
drop_closures_AttrFilterFunc :: AttrFilterFunc -> AttrFilterFunc_WithClosures
drop_closures_AttrFilterFunc AttrFilterFunc
_f Attribute
attribute Ptr ()
_ = AttrFilterFunc
_f Attribute
attribute
genClosure_AttrFilterFunc :: MonadIO m => AttrFilterFunc -> m (GClosure C_AttrFilterFunc)
genClosure_AttrFilterFunc :: forall (m :: * -> *).
MonadIO m =>
AttrFilterFunc -> m (GClosure C_AttrFilterFunc)
genClosure_AttrFilterFunc AttrFilterFunc
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: AttrFilterFunc_WithClosures
cb' = AttrFilterFunc -> AttrFilterFunc_WithClosures
drop_closures_AttrFilterFunc AttrFilterFunc
cb
let cb'' :: C_AttrFilterFunc
cb'' = Maybe (Ptr (FunPtr C_AttrFilterFunc))
-> AttrFilterFunc_WithClosures -> C_AttrFilterFunc
wrap_AttrFilterFunc forall a. Maybe a
Nothing AttrFilterFunc_WithClosures
cb'
C_AttrFilterFunc -> IO (FunPtr C_AttrFilterFunc)
mk_AttrFilterFunc C_AttrFilterFunc
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_AttrFilterFunc ::
Maybe (Ptr (FunPtr C_AttrFilterFunc)) ->
AttrFilterFunc_WithClosures ->
C_AttrFilterFunc
wrap_AttrFilterFunc :: Maybe (Ptr (FunPtr C_AttrFilterFunc))
-> AttrFilterFunc_WithClosures -> C_AttrFilterFunc
wrap_AttrFilterFunc Maybe (Ptr (FunPtr C_AttrFilterFunc))
gi'funptrptr AttrFilterFunc_WithClosures
gi'cb Ptr Attribute
attribute Ptr ()
userData = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Attribute
attribute forall a b. (a -> b) -> a -> b
$ \Attribute
attribute' -> do
Bool
result <- AttrFilterFunc_WithClosures
gi'cb Attribute
attribute' Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AttrFilterFunc))
gi'funptrptr
let result' :: CInt
result' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
result
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_AttrDataCopyFunc =
Ptr () ->
IO (Ptr ())
foreign import ccall "dynamic" __dynamic_C_AttrDataCopyFunc :: FunPtr C_AttrDataCopyFunc -> C_AttrDataCopyFunc
dynamic_AttrDataCopyFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_AttrDataCopyFunc
-> Ptr ()
-> m (Ptr ())
dynamic_AttrDataCopyFunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_AttrDataCopyFunc -> Ptr () -> m (Ptr ())
dynamic_AttrDataCopyFunc FunPtr C_AttrDataCopyFunc
__funPtr Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ()
result <- (FunPtr C_AttrDataCopyFunc -> C_AttrDataCopyFunc
__dynamic_C_AttrDataCopyFunc FunPtr C_AttrDataCopyFunc
__funPtr) Ptr ()
userData
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
foreign import ccall "wrapper"
mk_AttrDataCopyFunc :: C_AttrDataCopyFunc -> IO (FunPtr C_AttrDataCopyFunc)
type AttrDataCopyFunc =
IO (Ptr ())
noAttrDataCopyFunc :: Maybe AttrDataCopyFunc
noAttrDataCopyFunc :: Maybe (IO (Ptr ()))
noAttrDataCopyFunc = forall a. Maybe a
Nothing
type AttrDataCopyFunc_WithClosures =
Ptr ()
-> IO (Ptr ())
noAttrDataCopyFunc_WithClosures :: Maybe AttrDataCopyFunc_WithClosures
noAttrDataCopyFunc_WithClosures :: Maybe C_AttrDataCopyFunc
noAttrDataCopyFunc_WithClosures = forall a. Maybe a
Nothing
drop_closures_AttrDataCopyFunc :: AttrDataCopyFunc -> AttrDataCopyFunc_WithClosures
drop_closures_AttrDataCopyFunc :: IO (Ptr ()) -> C_AttrDataCopyFunc
drop_closures_AttrDataCopyFunc IO (Ptr ())
_f Ptr ()
_ = IO (Ptr ())
_f
genClosure_AttrDataCopyFunc :: MonadIO m => AttrDataCopyFunc -> m (GClosure C_AttrDataCopyFunc)
genClosure_AttrDataCopyFunc :: forall (m :: * -> *).
MonadIO m =>
IO (Ptr ()) -> m (GClosure C_AttrDataCopyFunc)
genClosure_AttrDataCopyFunc IO (Ptr ())
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_AttrDataCopyFunc
cb' = IO (Ptr ()) -> C_AttrDataCopyFunc
drop_closures_AttrDataCopyFunc IO (Ptr ())
cb
let cb'' :: C_AttrDataCopyFunc
cb'' = Maybe (Ptr (FunPtr C_AttrDataCopyFunc))
-> C_AttrDataCopyFunc -> C_AttrDataCopyFunc
wrap_AttrDataCopyFunc forall a. Maybe a
Nothing C_AttrDataCopyFunc
cb'
C_AttrDataCopyFunc -> IO (FunPtr C_AttrDataCopyFunc)
mk_AttrDataCopyFunc C_AttrDataCopyFunc
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_AttrDataCopyFunc ::
Maybe (Ptr (FunPtr C_AttrDataCopyFunc)) ->
AttrDataCopyFunc_WithClosures ->
C_AttrDataCopyFunc
wrap_AttrDataCopyFunc :: Maybe (Ptr (FunPtr C_AttrDataCopyFunc))
-> C_AttrDataCopyFunc -> C_AttrDataCopyFunc
wrap_AttrDataCopyFunc Maybe (Ptr (FunPtr C_AttrDataCopyFunc))
gi'funptrptr C_AttrDataCopyFunc
gi'cb Ptr ()
userData = do
Ptr ()
result <- C_AttrDataCopyFunc
gi'cb Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AttrDataCopyFunc))
gi'funptrptr
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
type C_AttrClassEqualFieldCallback =
Ptr Pango.Attribute.Attribute ->
Ptr Pango.Attribute.Attribute ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_AttrClassEqualFieldCallback :: FunPtr C_AttrClassEqualFieldCallback -> C_AttrClassEqualFieldCallback
dynamic_AttrClassEqualFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_AttrClassEqualFieldCallback
-> Pango.Attribute.Attribute
-> Pango.Attribute.Attribute
-> m Bool
dynamic_AttrClassEqualFieldCallback :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_AttrClassEqualFieldCallback
-> Attribute -> Attribute -> m Bool
dynamic_AttrClassEqualFieldCallback FunPtr C_AttrClassEqualFieldCallback
__funPtr Attribute
attr1 Attribute
attr2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr1' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr1
Ptr Attribute
attr2' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr2
CInt
result <- (FunPtr C_AttrClassEqualFieldCallback
-> C_AttrClassEqualFieldCallback
__dynamic_C_AttrClassEqualFieldCallback FunPtr C_AttrClassEqualFieldCallback
__funPtr) Ptr Attribute
attr1' Ptr Attribute
attr2'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr1
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr2
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_AttrClassEqualFieldCallback :: C_AttrClassEqualFieldCallback -> IO (FunPtr C_AttrClassEqualFieldCallback)
type AttrClassEqualFieldCallback =
Pango.Attribute.Attribute
-> Pango.Attribute.Attribute
-> IO Bool
noAttrClassEqualFieldCallback :: Maybe AttrClassEqualFieldCallback
noAttrClassEqualFieldCallback :: Maybe AttrClassEqualFieldCallback
noAttrClassEqualFieldCallback = forall a. Maybe a
Nothing
genClosure_AttrClassEqualFieldCallback :: MonadIO m => AttrClassEqualFieldCallback -> m (GClosure C_AttrClassEqualFieldCallback)
genClosure_AttrClassEqualFieldCallback :: forall (m :: * -> *).
MonadIO m =>
AttrClassEqualFieldCallback
-> m (GClosure C_AttrClassEqualFieldCallback)
genClosure_AttrClassEqualFieldCallback AttrClassEqualFieldCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_AttrClassEqualFieldCallback
cb' = Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback))
-> AttrClassEqualFieldCallback -> C_AttrClassEqualFieldCallback
wrap_AttrClassEqualFieldCallback forall a. Maybe a
Nothing AttrClassEqualFieldCallback
cb
C_AttrClassEqualFieldCallback
-> IO (FunPtr C_AttrClassEqualFieldCallback)
mk_AttrClassEqualFieldCallback C_AttrClassEqualFieldCallback
cb' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_AttrClassEqualFieldCallback ::
Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback)) ->
AttrClassEqualFieldCallback ->
C_AttrClassEqualFieldCallback
wrap_AttrClassEqualFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback))
-> AttrClassEqualFieldCallback -> C_AttrClassEqualFieldCallback
wrap_AttrClassEqualFieldCallback Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback))
gi'funptrptr AttrClassEqualFieldCallback
gi'cb Ptr Attribute
attr1 Ptr Attribute
attr2 = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Attribute
attr1 forall a b. (a -> b) -> a -> b
$ \Attribute
attr1' -> do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Attribute
attr2 forall a b. (a -> b) -> a -> b
$ \Attribute
attr2' -> do
Bool
result <- AttrClassEqualFieldCallback
gi'cb Attribute
attr1' Attribute
attr2'
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback))
gi'funptrptr
let result' :: CInt
result' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
result
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_AttrClassDestroyFieldCallback =
Ptr Pango.Attribute.Attribute ->
IO ()
foreign import ccall "dynamic" __dynamic_C_AttrClassDestroyFieldCallback :: FunPtr C_AttrClassDestroyFieldCallback -> C_AttrClassDestroyFieldCallback
dynamic_AttrClassDestroyFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_AttrClassDestroyFieldCallback
-> Pango.Attribute.Attribute
-> m ()
dynamic_AttrClassDestroyFieldCallback :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_AttrClassDestroyFieldCallback -> Attribute -> m ()
dynamic_AttrClassDestroyFieldCallback FunPtr C_AttrClassDestroyFieldCallback
__funPtr Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
(FunPtr C_AttrClassDestroyFieldCallback
-> C_AttrClassDestroyFieldCallback
__dynamic_C_AttrClassDestroyFieldCallback FunPtr C_AttrClassDestroyFieldCallback
__funPtr) Ptr Attribute
attr'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_AttrClassDestroyFieldCallback :: C_AttrClassDestroyFieldCallback -> IO (FunPtr C_AttrClassDestroyFieldCallback)
type AttrClassDestroyFieldCallback =
Pango.Attribute.Attribute
-> IO ()
noAttrClassDestroyFieldCallback :: Maybe AttrClassDestroyFieldCallback
noAttrClassDestroyFieldCallback :: Maybe AttrClassDestroyFieldCallback
noAttrClassDestroyFieldCallback = forall a. Maybe a
Nothing
genClosure_AttrClassDestroyFieldCallback :: MonadIO m => AttrClassDestroyFieldCallback -> m (GClosure C_AttrClassDestroyFieldCallback)
genClosure_AttrClassDestroyFieldCallback :: forall (m :: * -> *).
MonadIO m =>
AttrClassDestroyFieldCallback
-> m (GClosure C_AttrClassDestroyFieldCallback)
genClosure_AttrClassDestroyFieldCallback AttrClassDestroyFieldCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_AttrClassDestroyFieldCallback
cb' = Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
-> AttrClassDestroyFieldCallback -> C_AttrClassDestroyFieldCallback
wrap_AttrClassDestroyFieldCallback forall a. Maybe a
Nothing AttrClassDestroyFieldCallback
cb
C_AttrClassDestroyFieldCallback
-> IO (FunPtr C_AttrClassDestroyFieldCallback)
mk_AttrClassDestroyFieldCallback C_AttrClassDestroyFieldCallback
cb' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_AttrClassDestroyFieldCallback ::
Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback)) ->
AttrClassDestroyFieldCallback ->
C_AttrClassDestroyFieldCallback
wrap_AttrClassDestroyFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
-> AttrClassDestroyFieldCallback -> C_AttrClassDestroyFieldCallback
wrap_AttrClassDestroyFieldCallback Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
gi'funptrptr AttrClassDestroyFieldCallback
gi'cb Ptr Attribute
attr = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Attribute
attr forall a b. (a -> b) -> a -> b
$ \Attribute
attr' -> do
AttrClassDestroyFieldCallback
gi'cb Attribute
attr'
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
gi'funptrptr
type C_AttrClassCopyFieldCallback =
Ptr Pango.Attribute.Attribute ->
IO (Ptr Pango.Attribute.Attribute)
foreign import ccall "dynamic" __dynamic_C_AttrClassCopyFieldCallback :: FunPtr C_AttrClassCopyFieldCallback -> C_AttrClassCopyFieldCallback
dynamic_AttrClassCopyFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_AttrClassCopyFieldCallback
-> Pango.Attribute.Attribute
-> m Pango.Attribute.Attribute
dynamic_AttrClassCopyFieldCallback :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_AttrClassCopyFieldCallback -> Attribute -> m Attribute
dynamic_AttrClassCopyFieldCallback FunPtr C_AttrClassCopyFieldCallback
__funPtr Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr Attribute
result <- (FunPtr C_AttrClassCopyFieldCallback -> C_AttrClassCopyFieldCallback
__dynamic_C_AttrClassCopyFieldCallback FunPtr C_AttrClassCopyFieldCallback
__funPtr) Ptr Attribute
attr'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"attrClassCopyFieldCallback" Ptr Attribute
result
Attribute
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Attribute -> Attribute
Pango.Attribute.Attribute) Ptr Attribute
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Attribute
result'
foreign import ccall "wrapper"
mk_AttrClassCopyFieldCallback :: C_AttrClassCopyFieldCallback -> IO (FunPtr C_AttrClassCopyFieldCallback)
type AttrClassCopyFieldCallback =
Pango.Attribute.Attribute
-> IO Pango.Attribute.Attribute
noAttrClassCopyFieldCallback :: Maybe AttrClassCopyFieldCallback
noAttrClassCopyFieldCallback :: Maybe AttrClassCopyFieldCallback
noAttrClassCopyFieldCallback = forall a. Maybe a
Nothing
genClosure_AttrClassCopyFieldCallback :: MonadIO m => AttrClassCopyFieldCallback -> m (GClosure C_AttrClassCopyFieldCallback)
genClosure_AttrClassCopyFieldCallback :: forall (m :: * -> *).
MonadIO m =>
AttrClassCopyFieldCallback
-> m (GClosure C_AttrClassCopyFieldCallback)
genClosure_AttrClassCopyFieldCallback AttrClassCopyFieldCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_AttrClassCopyFieldCallback
cb' = Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback))
-> AttrClassCopyFieldCallback -> C_AttrClassCopyFieldCallback
wrap_AttrClassCopyFieldCallback forall a. Maybe a
Nothing AttrClassCopyFieldCallback
cb
C_AttrClassCopyFieldCallback
-> IO (FunPtr C_AttrClassCopyFieldCallback)
mk_AttrClassCopyFieldCallback C_AttrClassCopyFieldCallback
cb' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_AttrClassCopyFieldCallback ::
Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback)) ->
AttrClassCopyFieldCallback ->
C_AttrClassCopyFieldCallback
wrap_AttrClassCopyFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback))
-> AttrClassCopyFieldCallback -> C_AttrClassCopyFieldCallback
wrap_AttrClassCopyFieldCallback Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback))
gi'funptrptr AttrClassCopyFieldCallback
gi'cb Ptr Attribute
attr = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Attribute
attr forall a b. (a -> b) -> a -> b
$ \Attribute
attr' -> do
Attribute
result <- AttrClassCopyFieldCallback
gi'cb Attribute
attr'
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback))
gi'funptrptr
Ptr Attribute
result' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Attribute
result
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Attribute
result'