#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.GObject.Callbacks
(
BaseFinalizeFunc ,
C_BaseFinalizeFunc ,
dynamic_BaseFinalizeFunc ,
genClosure_BaseFinalizeFunc ,
mk_BaseFinalizeFunc ,
noBaseFinalizeFunc ,
wrap_BaseFinalizeFunc ,
BaseInitFunc ,
C_BaseInitFunc ,
dynamic_BaseInitFunc ,
genClosure_BaseInitFunc ,
mk_BaseInitFunc ,
noBaseInitFunc ,
wrap_BaseInitFunc ,
BindingTransformFunc ,
BindingTransformFunc_WithClosures ,
C_BindingTransformFunc ,
drop_closures_BindingTransformFunc ,
dynamic_BindingTransformFunc ,
genClosure_BindingTransformFunc ,
mk_BindingTransformFunc ,
noBindingTransformFunc ,
noBindingTransformFunc_WithClosures ,
wrap_BindingTransformFunc ,
BoxedCopyFunc ,
C_BoxedCopyFunc ,
dynamic_BoxedCopyFunc ,
genClosure_BoxedCopyFunc ,
mk_BoxedCopyFunc ,
noBoxedCopyFunc ,
wrap_BoxedCopyFunc ,
BoxedFreeFunc ,
C_BoxedFreeFunc ,
dynamic_BoxedFreeFunc ,
genClosure_BoxedFreeFunc ,
mk_BoxedFreeFunc ,
noBoxedFreeFunc ,
wrap_BoxedFreeFunc ,
C_Callback ,
Callback ,
dynamic_Callback ,
genClosure_Callback ,
mk_Callback ,
noCallback ,
wrap_Callback ,
C_ClassFinalizeFunc ,
ClassFinalizeFunc ,
dynamic_ClassFinalizeFunc ,
genClosure_ClassFinalizeFunc ,
mk_ClassFinalizeFunc ,
noClassFinalizeFunc ,
wrap_ClassFinalizeFunc ,
C_ClassInitFunc ,
ClassInitFunc ,
dynamic_ClassInitFunc ,
genClosure_ClassInitFunc ,
mk_ClassInitFunc ,
noClassInitFunc ,
wrap_ClassInitFunc ,
C_ClosureMarshalFieldCallback ,
ClosureMarshalFieldCallback ,
dynamic_ClosureMarshalFieldCallback ,
genClosure_ClosureMarshalFieldCallback ,
mk_ClosureMarshalFieldCallback ,
noClosureMarshalFieldCallback ,
wrap_ClosureMarshalFieldCallback ,
C_ClosureNotify ,
ClosureNotify ,
dynamic_ClosureNotify ,
genClosure_ClosureNotify ,
mk_ClosureNotify ,
noClosureNotify ,
wrap_ClosureNotify ,
C_InstanceInitFunc ,
InstanceInitFunc ,
dynamic_InstanceInitFunc ,
genClosure_InstanceInitFunc ,
mk_InstanceInitFunc ,
noInstanceInitFunc ,
wrap_InstanceInitFunc ,
C_InterfaceFinalizeFunc ,
InterfaceFinalizeFunc ,
dynamic_InterfaceFinalizeFunc ,
genClosure_InterfaceFinalizeFunc ,
mk_InterfaceFinalizeFunc ,
noInterfaceFinalizeFunc ,
wrap_InterfaceFinalizeFunc ,
C_InterfaceInitFunc ,
InterfaceInitFunc ,
dynamic_InterfaceInitFunc ,
genClosure_InterfaceInitFunc ,
mk_InterfaceInitFunc ,
noInterfaceInitFunc ,
wrap_InterfaceInitFunc ,
C_ObjectFinalizeFunc ,
ObjectFinalizeFunc ,
dynamic_ObjectFinalizeFunc ,
genClosure_ObjectFinalizeFunc ,
mk_ObjectFinalizeFunc ,
noObjectFinalizeFunc ,
wrap_ObjectFinalizeFunc ,
C_ObjectGetPropertyFunc ,
ObjectGetPropertyFunc ,
dynamic_ObjectGetPropertyFunc ,
genClosure_ObjectGetPropertyFunc ,
mk_ObjectGetPropertyFunc ,
noObjectGetPropertyFunc ,
wrap_ObjectGetPropertyFunc ,
C_ObjectSetPropertyFunc ,
ObjectSetPropertyFunc ,
dynamic_ObjectSetPropertyFunc ,
genClosure_ObjectSetPropertyFunc ,
mk_ObjectSetPropertyFunc ,
noObjectSetPropertyFunc ,
wrap_ObjectSetPropertyFunc ,
C_ParamSpecTypeInfoFinalizeFieldCallback,
ParamSpecTypeInfoFinalizeFieldCallback ,
dynamic_ParamSpecTypeInfoFinalizeFieldCallback,
genClosure_ParamSpecTypeInfoFinalizeFieldCallback,
mk_ParamSpecTypeInfoFinalizeFieldCallback,
noParamSpecTypeInfoFinalizeFieldCallback,
wrap_ParamSpecTypeInfoFinalizeFieldCallback,
C_ParamSpecTypeInfoInstanceInitFieldCallback,
ParamSpecTypeInfoInstanceInitFieldCallback,
dynamic_ParamSpecTypeInfoInstanceInitFieldCallback,
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback,
mk_ParamSpecTypeInfoInstanceInitFieldCallback,
noParamSpecTypeInfoInstanceInitFieldCallback,
wrap_ParamSpecTypeInfoInstanceInitFieldCallback,
C_ParamSpecTypeInfoValueSetDefaultFieldCallback,
ParamSpecTypeInfoValueSetDefaultFieldCallback,
dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback,
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback,
mk_ParamSpecTypeInfoValueSetDefaultFieldCallback,
noParamSpecTypeInfoValueSetDefaultFieldCallback,
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback,
C_ParamSpecTypeInfoValueValidateFieldCallback,
ParamSpecTypeInfoValueValidateFieldCallback,
dynamic_ParamSpecTypeInfoValueValidateFieldCallback,
genClosure_ParamSpecTypeInfoValueValidateFieldCallback,
mk_ParamSpecTypeInfoValueValidateFieldCallback,
noParamSpecTypeInfoValueValidateFieldCallback,
wrap_ParamSpecTypeInfoValueValidateFieldCallback,
C_ParamSpecTypeInfoValuesCmpFieldCallback,
ParamSpecTypeInfoValuesCmpFieldCallback ,
dynamic_ParamSpecTypeInfoValuesCmpFieldCallback,
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback,
mk_ParamSpecTypeInfoValuesCmpFieldCallback,
noParamSpecTypeInfoValuesCmpFieldCallback,
wrap_ParamSpecTypeInfoValuesCmpFieldCallback,
C_SignalAccumulator ,
SignalAccumulator ,
dynamic_SignalAccumulator ,
genClosure_SignalAccumulator ,
mk_SignalAccumulator ,
noSignalAccumulator ,
wrap_SignalAccumulator ,
C_SignalEmissionHook ,
SignalEmissionHook ,
dynamic_SignalEmissionHook ,
genClosure_SignalEmissionHook ,
mk_SignalEmissionHook ,
noSignalEmissionHook ,
wrap_SignalEmissionHook ,
C_ToggleNotify ,
ToggleNotify ,
dynamic_ToggleNotify ,
genClosure_ToggleNotify ,
mk_ToggleNotify ,
noToggleNotify ,
wrap_ToggleNotify ,
C_TypeClassCacheFunc ,
TypeClassCacheFunc ,
dynamic_TypeClassCacheFunc ,
genClosure_TypeClassCacheFunc ,
mk_TypeClassCacheFunc ,
noTypeClassCacheFunc ,
wrap_TypeClassCacheFunc ,
C_TypeInterfaceCheckFunc ,
TypeInterfaceCheckFunc ,
dynamic_TypeInterfaceCheckFunc ,
genClosure_TypeInterfaceCheckFunc ,
mk_TypeInterfaceCheckFunc ,
noTypeInterfaceCheckFunc ,
wrap_TypeInterfaceCheckFunc ,
C_TypePluginCompleteInterfaceInfo ,
TypePluginCompleteInterfaceInfo ,
dynamic_TypePluginCompleteInterfaceInfo ,
genClosure_TypePluginCompleteInterfaceInfo,
mk_TypePluginCompleteInterfaceInfo ,
noTypePluginCompleteInterfaceInfo ,
wrap_TypePluginCompleteInterfaceInfo ,
C_TypePluginCompleteTypeInfo ,
TypePluginCompleteTypeInfo ,
dynamic_TypePluginCompleteTypeInfo ,
genClosure_TypePluginCompleteTypeInfo ,
mk_TypePluginCompleteTypeInfo ,
noTypePluginCompleteTypeInfo ,
wrap_TypePluginCompleteTypeInfo ,
C_TypePluginUnuse ,
TypePluginUnuse ,
dynamic_TypePluginUnuse ,
genClosure_TypePluginUnuse ,
mk_TypePluginUnuse ,
noTypePluginUnuse ,
wrap_TypePluginUnuse ,
C_TypePluginUse ,
TypePluginUse ,
dynamic_TypePluginUse ,
genClosure_TypePluginUse ,
mk_TypePluginUse ,
noTypePluginUse ,
wrap_TypePluginUse ,
C_TypeValueTableCollectValueFieldCallback,
TypeValueTableCollectValueFieldCallback ,
dynamic_TypeValueTableCollectValueFieldCallback,
genClosure_TypeValueTableCollectValueFieldCallback,
mk_TypeValueTableCollectValueFieldCallback,
noTypeValueTableCollectValueFieldCallback,
wrap_TypeValueTableCollectValueFieldCallback,
C_TypeValueTableLcopyValueFieldCallback ,
TypeValueTableLcopyValueFieldCallback ,
dynamic_TypeValueTableLcopyValueFieldCallback,
genClosure_TypeValueTableLcopyValueFieldCallback,
mk_TypeValueTableLcopyValueFieldCallback,
noTypeValueTableLcopyValueFieldCallback ,
wrap_TypeValueTableLcopyValueFieldCallback,
C_TypeValueTableValueCopyFieldCallback ,
TypeValueTableValueCopyFieldCallback ,
dynamic_TypeValueTableValueCopyFieldCallback,
genClosure_TypeValueTableValueCopyFieldCallback,
mk_TypeValueTableValueCopyFieldCallback ,
noTypeValueTableValueCopyFieldCallback ,
wrap_TypeValueTableValueCopyFieldCallback,
C_TypeValueTableValueFreeFieldCallback ,
TypeValueTableValueFreeFieldCallback ,
dynamic_TypeValueTableValueFreeFieldCallback,
genClosure_TypeValueTableValueFreeFieldCallback,
mk_TypeValueTableValueFreeFieldCallback ,
noTypeValueTableValueFreeFieldCallback ,
wrap_TypeValueTableValueFreeFieldCallback,
C_TypeValueTableValueInitFieldCallback ,
TypeValueTableValueInitFieldCallback ,
dynamic_TypeValueTableValueInitFieldCallback,
genClosure_TypeValueTableValueInitFieldCallback,
mk_TypeValueTableValueInitFieldCallback ,
noTypeValueTableValueInitFieldCallback ,
wrap_TypeValueTableValueInitFieldCallback,
C_TypeValueTableValuePeekPointerFieldCallback,
TypeValueTableValuePeekPointerFieldCallback,
dynamic_TypeValueTableValuePeekPointerFieldCallback,
genClosure_TypeValueTableValuePeekPointerFieldCallback,
mk_TypeValueTableValuePeekPointerFieldCallback,
noTypeValueTableValuePeekPointerFieldCallback,
wrap_TypeValueTableValuePeekPointerFieldCallback,
C_ValueTransform ,
ValueTransform ,
dynamic_ValueTransform ,
genClosure_ValueTransform ,
mk_ValueTransform ,
noValueTransform ,
wrap_ValueTransform ,
C_WeakNotify ,
WeakNotify ,
dynamic_WeakNotify ,
genClosure_WeakNotify ,
mk_WeakNotify ,
noWeakNotify ,
wrap_WeakNotify ,
) 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 {-# SOURCE #-} qualified GI.GObject.Interfaces.TypePlugin as GObject.TypePlugin
import {-# SOURCE #-} qualified GI.GObject.Objects.Binding as GObject.Binding
import {-# SOURCE #-} qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.GObject.Structs.InterfaceInfo as GObject.InterfaceInfo
import {-# SOURCE #-} qualified GI.GObject.Structs.SignalInvocationHint as GObject.SignalInvocationHint
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeClass as GObject.TypeClass
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeInfo as GObject.TypeInfo
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeInstance as GObject.TypeInstance
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeInterface as GObject.TypeInterface
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeValueTable as GObject.TypeValueTable
import {-# SOURCE #-} qualified GI.GObject.Unions.TypeCValue as GObject.TypeCValue
type C_WeakNotify =
Ptr () ->
Ptr GObject.Object.Object ->
IO ()
foreign import ccall "dynamic" __dynamic_C_WeakNotify :: FunPtr C_WeakNotify -> C_WeakNotify
dynamic_WeakNotify ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
FunPtr C_WeakNotify
-> Ptr ()
-> a
-> m ()
dynamic_WeakNotify :: FunPtr C_WeakNotify -> Ptr () -> a -> m ()
dynamic_WeakNotify __funPtr :: FunPtr C_WeakNotify
__funPtr data_ :: Ptr ()
data_ whereTheObjectWas :: a
whereTheObjectWas = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
whereTheObjectWas' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
whereTheObjectWas
(FunPtr C_WeakNotify -> C_WeakNotify
__dynamic_C_WeakNotify FunPtr C_WeakNotify
__funPtr) Ptr ()
data_ Ptr Object
whereTheObjectWas'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
whereTheObjectWas
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify)
type WeakNotify =
Ptr ()
-> GObject.Object.Object
-> IO ()
noWeakNotify :: Maybe WeakNotify
noWeakNotify :: Maybe WeakNotify
noWeakNotify = Maybe WeakNotify
forall a. Maybe a
Nothing
genClosure_WeakNotify :: WeakNotify -> IO Closure
genClosure_WeakNotify :: WeakNotify -> IO Closure
genClosure_WeakNotify cb :: WeakNotify
cb = do
let cb' :: C_WeakNotify
cb' = Maybe (Ptr (FunPtr C_WeakNotify)) -> WeakNotify -> C_WeakNotify
wrap_WeakNotify Maybe (Ptr (FunPtr C_WeakNotify))
forall a. Maybe a
Nothing WeakNotify
cb
C_WeakNotify -> IO (FunPtr C_WeakNotify)
mk_WeakNotify C_WeakNotify
cb' IO (FunPtr C_WeakNotify)
-> (FunPtr C_WeakNotify -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WeakNotify -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_WeakNotify ::
Maybe (Ptr (FunPtr C_WeakNotify)) ->
WeakNotify ->
C_WeakNotify
wrap_WeakNotify :: Maybe (Ptr (FunPtr C_WeakNotify)) -> WeakNotify -> C_WeakNotify
wrap_WeakNotify funptrptr :: Maybe (Ptr (FunPtr C_WeakNotify))
funptrptr _cb :: WeakNotify
_cb data_ :: Ptr ()
data_ whereTheObjectWas :: Ptr Object
whereTheObjectWas = do
Object
whereTheObjectWas' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
whereTheObjectWas
WeakNotify
_cb Ptr ()
data_ Object
whereTheObjectWas'
Maybe (Ptr (FunPtr C_WeakNotify)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_WeakNotify))
funptrptr
type C_ValueTransform =
Ptr GValue ->
Ptr GValue ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ValueTransform :: FunPtr C_ValueTransform -> C_ValueTransform
dynamic_ValueTransform ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ValueTransform
-> GValue
-> GValue
-> m ()
dynamic_ValueTransform :: FunPtr C_ValueTransform -> GValue -> GValue -> m ()
dynamic_ValueTransform __funPtr :: FunPtr C_ValueTransform
__funPtr srcValue :: GValue
srcValue destValue :: GValue
destValue = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
srcValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
srcValue
Ptr GValue
destValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
destValue
(FunPtr C_ValueTransform -> C_ValueTransform
__dynamic_C_ValueTransform FunPtr C_ValueTransform
__funPtr) Ptr GValue
srcValue' Ptr GValue
destValue'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
srcValue
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
destValue
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform)
type ValueTransform =
GValue
-> GValue
-> IO ()
noValueTransform :: Maybe ValueTransform
noValueTransform :: Maybe ValueTransform
noValueTransform = Maybe ValueTransform
forall a. Maybe a
Nothing
genClosure_ValueTransform :: ValueTransform -> IO Closure
genClosure_ValueTransform :: ValueTransform -> IO Closure
genClosure_ValueTransform cb :: ValueTransform
cb = do
let cb' :: C_ValueTransform
cb' = Maybe (Ptr (FunPtr C_ValueTransform))
-> ValueTransform -> C_ValueTransform
wrap_ValueTransform Maybe (Ptr (FunPtr C_ValueTransform))
forall a. Maybe a
Nothing ValueTransform
cb
C_ValueTransform -> IO (FunPtr C_ValueTransform)
mk_ValueTransform C_ValueTransform
cb' IO (FunPtr C_ValueTransform)
-> (FunPtr C_ValueTransform -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ValueTransform -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ValueTransform ::
Maybe (Ptr (FunPtr C_ValueTransform)) ->
ValueTransform ->
C_ValueTransform
wrap_ValueTransform :: Maybe (Ptr (FunPtr C_ValueTransform))
-> ValueTransform -> C_ValueTransform
wrap_ValueTransform funptrptr :: Maybe (Ptr (FunPtr C_ValueTransform))
funptrptr _cb :: ValueTransform
_cb srcValue :: Ptr GValue
srcValue destValue :: Ptr GValue
destValue = do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
srcValue ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \srcValue' :: GValue
srcValue' -> do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
destValue ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \destValue' :: GValue
destValue' -> do
ValueTransform
_cb GValue
srcValue' GValue
destValue'
Maybe (Ptr (FunPtr C_ValueTransform)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ValueTransform))
funptrptr
type C_TypeValueTableValuePeekPointerFieldCallback =
Ptr GValue ->
IO (Ptr ())
foreign import ccall "dynamic" __dynamic_C_TypeValueTableValuePeekPointerFieldCallback :: FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> C_TypeValueTableValuePeekPointerFieldCallback
dynamic_TypeValueTableValuePeekPointerFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableValuePeekPointerFieldCallback
-> GValue
-> m (Ptr ())
dynamic_TypeValueTableValuePeekPointerFieldCallback :: FunPtr C_TypeValueTableValuePeekPointerFieldCallback
-> GValue -> m (Ptr ())
dynamic_TypeValueTableValuePeekPointerFieldCallback __funPtr :: FunPtr C_TypeValueTableValuePeekPointerFieldCallback
__funPtr value :: GValue
value = 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
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr ()
result <- (FunPtr C_TypeValueTableValuePeekPointerFieldCallback
-> C_TypeValueTableValuePeekPointerFieldCallback
__dynamic_C_TypeValueTableValuePeekPointerFieldCallback FunPtr C_TypeValueTableValuePeekPointerFieldCallback
__funPtr) Ptr GValue
value'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
foreign import ccall "wrapper"
mk_TypeValueTableValuePeekPointerFieldCallback :: C_TypeValueTableValuePeekPointerFieldCallback -> IO (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)
type TypeValueTableValuePeekPointerFieldCallback =
GValue
-> IO (Ptr ())
noTypeValueTableValuePeekPointerFieldCallback :: Maybe TypeValueTableValuePeekPointerFieldCallback
noTypeValueTableValuePeekPointerFieldCallback :: Maybe TypeValueTableValuePeekPointerFieldCallback
noTypeValueTableValuePeekPointerFieldCallback = Maybe TypeValueTableValuePeekPointerFieldCallback
forall a. Maybe a
Nothing
genClosure_TypeValueTableValuePeekPointerFieldCallback :: TypeValueTableValuePeekPointerFieldCallback -> IO Closure
genClosure_TypeValueTableValuePeekPointerFieldCallback :: TypeValueTableValuePeekPointerFieldCallback -> IO Closure
genClosure_TypeValueTableValuePeekPointerFieldCallback cb :: TypeValueTableValuePeekPointerFieldCallback
cb = do
let cb' :: C_TypeValueTableValuePeekPointerFieldCallback
cb' = Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback))
-> TypeValueTableValuePeekPointerFieldCallback
-> C_TypeValueTableValuePeekPointerFieldCallback
wrap_TypeValueTableValuePeekPointerFieldCallback Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback))
forall a. Maybe a
Nothing TypeValueTableValuePeekPointerFieldCallback
cb
C_TypeValueTableValuePeekPointerFieldCallback
-> IO (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)
mk_TypeValueTableValuePeekPointerFieldCallback C_TypeValueTableValuePeekPointerFieldCallback
cb' IO (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)
-> (FunPtr C_TypeValueTableValuePeekPointerFieldCallback
-> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypeValueTableValuePeekPointerFieldCallback ::
Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)) ->
TypeValueTableValuePeekPointerFieldCallback ->
C_TypeValueTableValuePeekPointerFieldCallback
wrap_TypeValueTableValuePeekPointerFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback))
-> TypeValueTableValuePeekPointerFieldCallback
-> C_TypeValueTableValuePeekPointerFieldCallback
wrap_TypeValueTableValuePeekPointerFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback))
funptrptr _cb :: TypeValueTableValuePeekPointerFieldCallback
_cb value :: Ptr GValue
value = do
(ManagedPtr GValue -> GValue)
-> Ptr GValue
-> TypeValueTableValuePeekPointerFieldCallback
-> IO (Ptr ())
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value (TypeValueTableValuePeekPointerFieldCallback -> IO (Ptr ()))
-> TypeValueTableValuePeekPointerFieldCallback -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
Ptr ()
result <- TypeValueTableValuePeekPointerFieldCallback
_cb GValue
value'
Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback))
funptrptr
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
type C_TypeValueTableValueInitFieldCallback =
Ptr GValue ->
IO ()
foreign import ccall "dynamic" __dynamic_C_TypeValueTableValueInitFieldCallback :: FunPtr C_TypeValueTableValueInitFieldCallback -> C_TypeValueTableValueInitFieldCallback
dynamic_TypeValueTableValueInitFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableValueInitFieldCallback
-> GValue
-> m ()
dynamic_TypeValueTableValueInitFieldCallback :: FunPtr C_TypeValueTableValueInitFieldCallback -> GValue -> m ()
dynamic_TypeValueTableValueInitFieldCallback __funPtr :: FunPtr C_TypeValueTableValueInitFieldCallback
__funPtr value :: GValue
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
(FunPtr C_TypeValueTableValueInitFieldCallback
-> C_TypeValueTableValueInitFieldCallback
__dynamic_C_TypeValueTableValueInitFieldCallback FunPtr C_TypeValueTableValueInitFieldCallback
__funPtr) Ptr GValue
value'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_TypeValueTableValueInitFieldCallback :: C_TypeValueTableValueInitFieldCallback -> IO (FunPtr C_TypeValueTableValueInitFieldCallback)
type TypeValueTableValueInitFieldCallback =
GValue
-> IO ()
noTypeValueTableValueInitFieldCallback :: Maybe TypeValueTableValueInitFieldCallback
noTypeValueTableValueInitFieldCallback :: Maybe (GValue -> IO ())
noTypeValueTableValueInitFieldCallback = Maybe (GValue -> IO ())
forall a. Maybe a
Nothing
genClosure_TypeValueTableValueInitFieldCallback :: TypeValueTableValueInitFieldCallback -> IO Closure
genClosure_TypeValueTableValueInitFieldCallback :: (GValue -> IO ()) -> IO Closure
genClosure_TypeValueTableValueInitFieldCallback cb :: GValue -> IO ()
cb = do
let cb' :: C_TypeValueTableValueInitFieldCallback
cb' = Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
-> (GValue -> IO ()) -> C_TypeValueTableValueInitFieldCallback
wrap_TypeValueTableValueInitFieldCallback Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
forall a. Maybe a
Nothing GValue -> IO ()
cb
C_TypeValueTableValueInitFieldCallback
-> IO (FunPtr C_TypeValueTableValueInitFieldCallback)
mk_TypeValueTableValueInitFieldCallback C_TypeValueTableValueInitFieldCallback
cb' IO (FunPtr C_TypeValueTableValueInitFieldCallback)
-> (FunPtr C_TypeValueTableValueInitFieldCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypeValueTableValueInitFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypeValueTableValueInitFieldCallback ::
Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback)) ->
TypeValueTableValueInitFieldCallback ->
C_TypeValueTableValueInitFieldCallback
wrap_TypeValueTableValueInitFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
-> (GValue -> IO ()) -> C_TypeValueTableValueInitFieldCallback
wrap_TypeValueTableValueInitFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
funptrptr _cb :: GValue -> IO ()
_cb value :: Ptr GValue
value = do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
GValue -> IO ()
_cb GValue
value'
Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
funptrptr
type C_TypeValueTableValueFreeFieldCallback =
Ptr GValue ->
IO ()
foreign import ccall "dynamic" __dynamic_C_TypeValueTableValueFreeFieldCallback :: FunPtr C_TypeValueTableValueFreeFieldCallback -> C_TypeValueTableValueFreeFieldCallback
dynamic_TypeValueTableValueFreeFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableValueFreeFieldCallback
-> GValue
-> m ()
dynamic_TypeValueTableValueFreeFieldCallback :: FunPtr C_TypeValueTableValueInitFieldCallback -> GValue -> m ()
dynamic_TypeValueTableValueFreeFieldCallback __funPtr :: FunPtr C_TypeValueTableValueInitFieldCallback
__funPtr value :: GValue
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
(FunPtr C_TypeValueTableValueInitFieldCallback
-> C_TypeValueTableValueInitFieldCallback
__dynamic_C_TypeValueTableValueFreeFieldCallback FunPtr C_TypeValueTableValueInitFieldCallback
__funPtr) Ptr GValue
value'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_TypeValueTableValueFreeFieldCallback :: C_TypeValueTableValueFreeFieldCallback -> IO (FunPtr C_TypeValueTableValueFreeFieldCallback)
type TypeValueTableValueFreeFieldCallback =
GValue
-> IO ()
noTypeValueTableValueFreeFieldCallback :: Maybe TypeValueTableValueFreeFieldCallback
noTypeValueTableValueFreeFieldCallback :: Maybe (GValue -> IO ())
noTypeValueTableValueFreeFieldCallback = Maybe (GValue -> IO ())
forall a. Maybe a
Nothing
genClosure_TypeValueTableValueFreeFieldCallback :: TypeValueTableValueFreeFieldCallback -> IO Closure
genClosure_TypeValueTableValueFreeFieldCallback :: (GValue -> IO ()) -> IO Closure
genClosure_TypeValueTableValueFreeFieldCallback cb :: GValue -> IO ()
cb = do
let cb' :: C_TypeValueTableValueInitFieldCallback
cb' = Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
-> (GValue -> IO ()) -> C_TypeValueTableValueInitFieldCallback
wrap_TypeValueTableValueFreeFieldCallback Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
forall a. Maybe a
Nothing GValue -> IO ()
cb
C_TypeValueTableValueInitFieldCallback
-> IO (FunPtr C_TypeValueTableValueInitFieldCallback)
mk_TypeValueTableValueFreeFieldCallback C_TypeValueTableValueInitFieldCallback
cb' IO (FunPtr C_TypeValueTableValueInitFieldCallback)
-> (FunPtr C_TypeValueTableValueInitFieldCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypeValueTableValueInitFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypeValueTableValueFreeFieldCallback ::
Maybe (Ptr (FunPtr C_TypeValueTableValueFreeFieldCallback)) ->
TypeValueTableValueFreeFieldCallback ->
C_TypeValueTableValueFreeFieldCallback
wrap_TypeValueTableValueFreeFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
-> (GValue -> IO ()) -> C_TypeValueTableValueInitFieldCallback
wrap_TypeValueTableValueFreeFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
funptrptr _cb :: GValue -> IO ()
_cb value :: Ptr GValue
value = do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
GValue -> IO ()
_cb GValue
value'
Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback))
funptrptr
type C_TypeValueTableValueCopyFieldCallback =
Ptr GValue ->
Ptr GValue ->
IO ()
foreign import ccall "dynamic" __dynamic_C_TypeValueTableValueCopyFieldCallback :: FunPtr C_TypeValueTableValueCopyFieldCallback -> C_TypeValueTableValueCopyFieldCallback
dynamic_TypeValueTableValueCopyFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableValueCopyFieldCallback
-> GValue
-> GValue
-> m ()
dynamic_TypeValueTableValueCopyFieldCallback :: FunPtr C_ValueTransform -> GValue -> GValue -> m ()
dynamic_TypeValueTableValueCopyFieldCallback __funPtr :: FunPtr C_ValueTransform
__funPtr srcValue :: GValue
srcValue destValue :: GValue
destValue = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
srcValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
srcValue
Ptr GValue
destValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
destValue
(FunPtr C_ValueTransform -> C_ValueTransform
__dynamic_C_TypeValueTableValueCopyFieldCallback FunPtr C_ValueTransform
__funPtr) Ptr GValue
srcValue' Ptr GValue
destValue'
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
srcValue
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
destValue
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_TypeValueTableValueCopyFieldCallback :: C_TypeValueTableValueCopyFieldCallback -> IO (FunPtr C_TypeValueTableValueCopyFieldCallback)
type TypeValueTableValueCopyFieldCallback =
GValue
-> GValue
-> IO ()
noTypeValueTableValueCopyFieldCallback :: Maybe TypeValueTableValueCopyFieldCallback
noTypeValueTableValueCopyFieldCallback :: Maybe ValueTransform
noTypeValueTableValueCopyFieldCallback = Maybe ValueTransform
forall a. Maybe a
Nothing
genClosure_TypeValueTableValueCopyFieldCallback :: TypeValueTableValueCopyFieldCallback -> IO Closure
genClosure_TypeValueTableValueCopyFieldCallback :: ValueTransform -> IO Closure
genClosure_TypeValueTableValueCopyFieldCallback cb :: ValueTransform
cb = do
let cb' :: C_ValueTransform
cb' = Maybe (Ptr (FunPtr C_ValueTransform))
-> ValueTransform -> C_ValueTransform
wrap_TypeValueTableValueCopyFieldCallback Maybe (Ptr (FunPtr C_ValueTransform))
forall a. Maybe a
Nothing ValueTransform
cb
C_ValueTransform -> IO (FunPtr C_ValueTransform)
mk_TypeValueTableValueCopyFieldCallback C_ValueTransform
cb' IO (FunPtr C_ValueTransform)
-> (FunPtr C_ValueTransform -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ValueTransform -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypeValueTableValueCopyFieldCallback ::
Maybe (Ptr (FunPtr C_TypeValueTableValueCopyFieldCallback)) ->
TypeValueTableValueCopyFieldCallback ->
C_TypeValueTableValueCopyFieldCallback
wrap_TypeValueTableValueCopyFieldCallback :: Maybe (Ptr (FunPtr C_ValueTransform))
-> ValueTransform -> C_ValueTransform
wrap_TypeValueTableValueCopyFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_ValueTransform))
funptrptr _cb :: ValueTransform
_cb srcValue :: Ptr GValue
srcValue destValue :: Ptr GValue
destValue = do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
srcValue ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \srcValue' :: GValue
srcValue' -> do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
destValue ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \destValue' :: GValue
destValue' -> do
ValueTransform
_cb GValue
srcValue' GValue
destValue'
Maybe (Ptr (FunPtr C_ValueTransform)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ValueTransform))
funptrptr
type C_TypeValueTableLcopyValueFieldCallback =
Ptr GValue ->
Word32 ->
Ptr GObject.TypeCValue.TypeCValue ->
Word32 ->
IO CString
foreign import ccall "dynamic" __dynamic_C_TypeValueTableLcopyValueFieldCallback :: FunPtr C_TypeValueTableLcopyValueFieldCallback -> C_TypeValueTableLcopyValueFieldCallback
dynamic_TypeValueTableLcopyValueFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableLcopyValueFieldCallback
-> GValue
-> Word32
-> GObject.TypeCValue.TypeCValue
-> Word32
-> m T.Text
dynamic_TypeValueTableLcopyValueFieldCallback :: FunPtr C_TypeValueTableLcopyValueFieldCallback
-> GValue -> Word32 -> TypeCValue -> Word32 -> m Text
dynamic_TypeValueTableLcopyValueFieldCallback __funPtr :: FunPtr C_TypeValueTableLcopyValueFieldCallback
__funPtr value :: GValue
value nCollectValues :: Word32
nCollectValues collectValues :: TypeCValue
collectValues collectFlags :: Word32
collectFlags = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr TypeCValue
collectValues' <- TypeCValue -> IO (Ptr TypeCValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeCValue
collectValues
CString
result <- (FunPtr C_TypeValueTableLcopyValueFieldCallback
-> C_TypeValueTableLcopyValueFieldCallback
__dynamic_C_TypeValueTableLcopyValueFieldCallback FunPtr C_TypeValueTableLcopyValueFieldCallback
__funPtr) Ptr GValue
value' Word32
nCollectValues Ptr TypeCValue
collectValues' Word32
collectFlags
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "typeValueTableLcopyValueFieldCallback" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
TypeCValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeCValue
collectValues
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "wrapper"
mk_TypeValueTableLcopyValueFieldCallback :: C_TypeValueTableLcopyValueFieldCallback -> IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)
type TypeValueTableLcopyValueFieldCallback =
GValue
-> Word32
-> GObject.TypeCValue.TypeCValue
-> Word32
-> IO T.Text
noTypeValueTableLcopyValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback
noTypeValueTableLcopyValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback
noTypeValueTableLcopyValueFieldCallback = Maybe TypeValueTableLcopyValueFieldCallback
forall a. Maybe a
Nothing
genClosure_TypeValueTableLcopyValueFieldCallback :: TypeValueTableLcopyValueFieldCallback -> IO Closure
genClosure_TypeValueTableLcopyValueFieldCallback :: TypeValueTableLcopyValueFieldCallback -> IO Closure
genClosure_TypeValueTableLcopyValueFieldCallback cb :: TypeValueTableLcopyValueFieldCallback
cb = do
let cb' :: C_TypeValueTableLcopyValueFieldCallback
cb' = Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
-> TypeValueTableLcopyValueFieldCallback
-> C_TypeValueTableLcopyValueFieldCallback
wrap_TypeValueTableLcopyValueFieldCallback Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
forall a. Maybe a
Nothing TypeValueTableLcopyValueFieldCallback
cb
C_TypeValueTableLcopyValueFieldCallback
-> IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)
mk_TypeValueTableLcopyValueFieldCallback C_TypeValueTableLcopyValueFieldCallback
cb' IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)
-> (FunPtr C_TypeValueTableLcopyValueFieldCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypeValueTableLcopyValueFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypeValueTableLcopyValueFieldCallback ::
Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback)) ->
TypeValueTableLcopyValueFieldCallback ->
C_TypeValueTableLcopyValueFieldCallback
wrap_TypeValueTableLcopyValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
-> TypeValueTableLcopyValueFieldCallback
-> C_TypeValueTableLcopyValueFieldCallback
wrap_TypeValueTableLcopyValueFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
funptrptr _cb :: TypeValueTableLcopyValueFieldCallback
_cb value :: Ptr GValue
value nCollectValues :: Word32
nCollectValues collectValues :: Ptr TypeCValue
collectValues collectFlags :: Word32
collectFlags = do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO CString) -> IO CString
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value ((GValue -> IO CString) -> IO CString)
-> (GValue -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
TypeCValue
collectValues' <- ((ManagedPtr TypeCValue -> TypeCValue)
-> Ptr TypeCValue -> IO TypeCValue
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeCValue -> TypeCValue
GObject.TypeCValue.TypeCValue) Ptr TypeCValue
collectValues
Text
result <- TypeValueTableLcopyValueFieldCallback
_cb GValue
value' Word32
nCollectValues TypeCValue
collectValues' Word32
collectFlags
Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
funptrptr
CString
result' <- Text -> IO CString
textToCString Text
result
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
result'
type C_TypeValueTableCollectValueFieldCallback =
Ptr GValue ->
Word32 ->
Ptr GObject.TypeCValue.TypeCValue ->
Word32 ->
IO CString
foreign import ccall "dynamic" __dynamic_C_TypeValueTableCollectValueFieldCallback :: FunPtr C_TypeValueTableCollectValueFieldCallback -> C_TypeValueTableCollectValueFieldCallback
dynamic_TypeValueTableCollectValueFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TypeValueTableCollectValueFieldCallback
-> GValue
-> Word32
-> GObject.TypeCValue.TypeCValue
-> Word32
-> m T.Text
dynamic_TypeValueTableCollectValueFieldCallback :: FunPtr C_TypeValueTableLcopyValueFieldCallback
-> GValue -> Word32 -> TypeCValue -> Word32 -> m Text
dynamic_TypeValueTableCollectValueFieldCallback __funPtr :: FunPtr C_TypeValueTableLcopyValueFieldCallback
__funPtr value :: GValue
value nCollectValues :: Word32
nCollectValues collectValues :: TypeCValue
collectValues collectFlags :: Word32
collectFlags = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr TypeCValue
collectValues' <- TypeCValue -> IO (Ptr TypeCValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeCValue
collectValues
CString
result <- (FunPtr C_TypeValueTableLcopyValueFieldCallback
-> C_TypeValueTableLcopyValueFieldCallback
__dynamic_C_TypeValueTableCollectValueFieldCallback FunPtr C_TypeValueTableLcopyValueFieldCallback
__funPtr) Ptr GValue
value' Word32
nCollectValues Ptr TypeCValue
collectValues' Word32
collectFlags
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "typeValueTableCollectValueFieldCallback" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
TypeCValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeCValue
collectValues
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "wrapper"
mk_TypeValueTableCollectValueFieldCallback :: C_TypeValueTableCollectValueFieldCallback -> IO (FunPtr C_TypeValueTableCollectValueFieldCallback)
type TypeValueTableCollectValueFieldCallback =
GValue
-> Word32
-> GObject.TypeCValue.TypeCValue
-> Word32
-> IO T.Text
noTypeValueTableCollectValueFieldCallback :: Maybe TypeValueTableCollectValueFieldCallback
noTypeValueTableCollectValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback
noTypeValueTableCollectValueFieldCallback = Maybe TypeValueTableLcopyValueFieldCallback
forall a. Maybe a
Nothing
genClosure_TypeValueTableCollectValueFieldCallback :: TypeValueTableCollectValueFieldCallback -> IO Closure
genClosure_TypeValueTableCollectValueFieldCallback :: TypeValueTableLcopyValueFieldCallback -> IO Closure
genClosure_TypeValueTableCollectValueFieldCallback cb :: TypeValueTableLcopyValueFieldCallback
cb = do
let cb' :: C_TypeValueTableLcopyValueFieldCallback
cb' = Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
-> TypeValueTableLcopyValueFieldCallback
-> C_TypeValueTableLcopyValueFieldCallback
wrap_TypeValueTableCollectValueFieldCallback Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
forall a. Maybe a
Nothing TypeValueTableLcopyValueFieldCallback
cb
C_TypeValueTableLcopyValueFieldCallback
-> IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)
mk_TypeValueTableCollectValueFieldCallback C_TypeValueTableLcopyValueFieldCallback
cb' IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)
-> (FunPtr C_TypeValueTableLcopyValueFieldCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypeValueTableLcopyValueFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypeValueTableCollectValueFieldCallback ::
Maybe (Ptr (FunPtr C_TypeValueTableCollectValueFieldCallback)) ->
TypeValueTableCollectValueFieldCallback ->
C_TypeValueTableCollectValueFieldCallback
wrap_TypeValueTableCollectValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
-> TypeValueTableLcopyValueFieldCallback
-> C_TypeValueTableLcopyValueFieldCallback
wrap_TypeValueTableCollectValueFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
funptrptr _cb :: TypeValueTableLcopyValueFieldCallback
_cb value :: Ptr GValue
value nCollectValues :: Word32
nCollectValues collectValues :: Ptr TypeCValue
collectValues collectFlags :: Word32
collectFlags = do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO CString) -> IO CString
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value ((GValue -> IO CString) -> IO CString)
-> (GValue -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
TypeCValue
collectValues' <- ((ManagedPtr TypeCValue -> TypeCValue)
-> Ptr TypeCValue -> IO TypeCValue
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeCValue -> TypeCValue
GObject.TypeCValue.TypeCValue) Ptr TypeCValue
collectValues
Text
result <- TypeValueTableLcopyValueFieldCallback
_cb GValue
value' Word32
nCollectValues TypeCValue
collectValues' Word32
collectFlags
Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback))
funptrptr
CString
result' <- Text -> IO CString
textToCString Text
result
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
result'
type C_TypePluginUse =
Ptr GObject.TypePlugin.TypePlugin ->
IO ()
foreign import ccall "dynamic" __dynamic_C_TypePluginUse :: FunPtr C_TypePluginUse -> C_TypePluginUse
dynamic_TypePluginUse ::
(B.CallStack.HasCallStack, MonadIO m, GObject.TypePlugin.IsTypePlugin a) =>
FunPtr C_TypePluginUse
-> a
-> m ()
dynamic_TypePluginUse :: FunPtr C_TypePluginUse -> a -> m ()
dynamic_TypePluginUse __funPtr :: FunPtr C_TypePluginUse
__funPtr plugin :: a
plugin = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypePlugin
plugin' <- a -> IO (Ptr TypePlugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
(FunPtr C_TypePluginUse -> C_TypePluginUse
__dynamic_C_TypePluginUse FunPtr C_TypePluginUse
__funPtr) Ptr TypePlugin
plugin'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse)
type TypePluginUse =
GObject.TypePlugin.TypePlugin
-> IO ()
noTypePluginUse :: Maybe TypePluginUse
noTypePluginUse :: Maybe TypePluginUse
noTypePluginUse = Maybe TypePluginUse
forall a. Maybe a
Nothing
genClosure_TypePluginUse :: TypePluginUse -> IO Closure
genClosure_TypePluginUse :: TypePluginUse -> IO Closure
genClosure_TypePluginUse cb :: TypePluginUse
cb = do
let cb' :: C_TypePluginUse
cb' = Maybe (Ptr (FunPtr C_TypePluginUse))
-> TypePluginUse -> C_TypePluginUse
wrap_TypePluginUse Maybe (Ptr (FunPtr C_TypePluginUse))
forall a. Maybe a
Nothing TypePluginUse
cb
C_TypePluginUse -> IO (FunPtr C_TypePluginUse)
mk_TypePluginUse C_TypePluginUse
cb' IO (FunPtr C_TypePluginUse)
-> (FunPtr C_TypePluginUse -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypePluginUse -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypePluginUse ::
Maybe (Ptr (FunPtr C_TypePluginUse)) ->
TypePluginUse ->
C_TypePluginUse
wrap_TypePluginUse :: Maybe (Ptr (FunPtr C_TypePluginUse))
-> TypePluginUse -> C_TypePluginUse
wrap_TypePluginUse funptrptr :: Maybe (Ptr (FunPtr C_TypePluginUse))
funptrptr _cb :: TypePluginUse
_cb plugin :: Ptr TypePlugin
plugin = do
TypePlugin
plugin' <- ((ManagedPtr TypePlugin -> TypePlugin)
-> Ptr TypePlugin -> IO TypePlugin
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypePlugin -> TypePlugin
GObject.TypePlugin.TypePlugin) Ptr TypePlugin
plugin
TypePluginUse
_cb TypePlugin
plugin'
Maybe (Ptr (FunPtr C_TypePluginUse)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypePluginUse))
funptrptr
type C_TypePluginUnuse =
Ptr GObject.TypePlugin.TypePlugin ->
IO ()
foreign import ccall "dynamic" __dynamic_C_TypePluginUnuse :: FunPtr C_TypePluginUnuse -> C_TypePluginUnuse
dynamic_TypePluginUnuse ::
(B.CallStack.HasCallStack, MonadIO m, GObject.TypePlugin.IsTypePlugin a) =>
FunPtr C_TypePluginUnuse
-> a
-> m ()
dynamic_TypePluginUnuse :: FunPtr C_TypePluginUse -> a -> m ()
dynamic_TypePluginUnuse __funPtr :: FunPtr C_TypePluginUse
__funPtr plugin :: a
plugin = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypePlugin
plugin' <- a -> IO (Ptr TypePlugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
(FunPtr C_TypePluginUse -> C_TypePluginUse
__dynamic_C_TypePluginUnuse FunPtr C_TypePluginUse
__funPtr) Ptr TypePlugin
plugin'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse)
type TypePluginUnuse =
GObject.TypePlugin.TypePlugin
-> IO ()
noTypePluginUnuse :: Maybe TypePluginUnuse
noTypePluginUnuse :: Maybe TypePluginUse
noTypePluginUnuse = Maybe TypePluginUse
forall a. Maybe a
Nothing
genClosure_TypePluginUnuse :: TypePluginUnuse -> IO Closure
genClosure_TypePluginUnuse :: TypePluginUse -> IO Closure
genClosure_TypePluginUnuse cb :: TypePluginUse
cb = do
let cb' :: C_TypePluginUse
cb' = Maybe (Ptr (FunPtr C_TypePluginUse))
-> TypePluginUse -> C_TypePluginUse
wrap_TypePluginUnuse Maybe (Ptr (FunPtr C_TypePluginUse))
forall a. Maybe a
Nothing TypePluginUse
cb
C_TypePluginUse -> IO (FunPtr C_TypePluginUse)
mk_TypePluginUnuse C_TypePluginUse
cb' IO (FunPtr C_TypePluginUse)
-> (FunPtr C_TypePluginUse -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypePluginUse -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypePluginUnuse ::
Maybe (Ptr (FunPtr C_TypePluginUnuse)) ->
TypePluginUnuse ->
C_TypePluginUnuse
wrap_TypePluginUnuse :: Maybe (Ptr (FunPtr C_TypePluginUse))
-> TypePluginUse -> C_TypePluginUse
wrap_TypePluginUnuse funptrptr :: Maybe (Ptr (FunPtr C_TypePluginUse))
funptrptr _cb :: TypePluginUse
_cb plugin :: Ptr TypePlugin
plugin = do
TypePlugin
plugin' <- ((ManagedPtr TypePlugin -> TypePlugin)
-> Ptr TypePlugin -> IO TypePlugin
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypePlugin -> TypePlugin
GObject.TypePlugin.TypePlugin) Ptr TypePlugin
plugin
TypePluginUse
_cb TypePlugin
plugin'
Maybe (Ptr (FunPtr C_TypePluginUse)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypePluginUse))
funptrptr
type C_TypePluginCompleteTypeInfo =
Ptr GObject.TypePlugin.TypePlugin ->
CGType ->
Ptr GObject.TypeInfo.TypeInfo ->
Ptr GObject.TypeValueTable.TypeValueTable ->
IO ()
foreign import ccall "dynamic" __dynamic_C_TypePluginCompleteTypeInfo :: FunPtr C_TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo
dynamic_TypePluginCompleteTypeInfo ::
(B.CallStack.HasCallStack, MonadIO m, GObject.TypePlugin.IsTypePlugin a) =>
FunPtr C_TypePluginCompleteTypeInfo
-> a
-> GType
-> GObject.TypeInfo.TypeInfo
-> GObject.TypeValueTable.TypeValueTable
-> m ()
dynamic_TypePluginCompleteTypeInfo :: FunPtr C_TypePluginCompleteTypeInfo
-> a -> GType -> TypeInfo -> TypeValueTable -> m ()
dynamic_TypePluginCompleteTypeInfo __funPtr :: FunPtr C_TypePluginCompleteTypeInfo
__funPtr plugin :: a
plugin gType :: GType
gType info :: TypeInfo
info valueTable :: TypeValueTable
valueTable = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypePlugin
plugin' <- a -> IO (Ptr TypePlugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
let gType' :: CGType
gType' = GType -> CGType
gtypeToCGType GType
gType
Ptr TypeInfo
info' <- TypeInfo -> IO (Ptr TypeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeInfo
info
Ptr TypeValueTable
valueTable' <- TypeValueTable -> IO (Ptr TypeValueTable)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeValueTable
valueTable
(FunPtr C_TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo
__dynamic_C_TypePluginCompleteTypeInfo FunPtr C_TypePluginCompleteTypeInfo
__funPtr) Ptr TypePlugin
plugin' CGType
gType' Ptr TypeInfo
info' Ptr TypeValueTable
valueTable'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
TypeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeInfo
info
TypeValueTable -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeValueTable
valueTable
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo)
type TypePluginCompleteTypeInfo =
GObject.TypePlugin.TypePlugin
-> GType
-> GObject.TypeInfo.TypeInfo
-> GObject.TypeValueTable.TypeValueTable
-> IO ()
noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo
noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo
noTypePluginCompleteTypeInfo = Maybe TypePluginCompleteTypeInfo
forall a. Maybe a
Nothing
genClosure_TypePluginCompleteTypeInfo :: TypePluginCompleteTypeInfo -> IO Closure
genClosure_TypePluginCompleteTypeInfo :: TypePluginCompleteTypeInfo -> IO Closure
genClosure_TypePluginCompleteTypeInfo cb :: TypePluginCompleteTypeInfo
cb = do
let cb' :: C_TypePluginCompleteTypeInfo
cb' = Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo))
-> TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo
wrap_TypePluginCompleteTypeInfo Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo))
forall a. Maybe a
Nothing TypePluginCompleteTypeInfo
cb
C_TypePluginCompleteTypeInfo
-> IO (FunPtr C_TypePluginCompleteTypeInfo)
mk_TypePluginCompleteTypeInfo C_TypePluginCompleteTypeInfo
cb' IO (FunPtr C_TypePluginCompleteTypeInfo)
-> (FunPtr C_TypePluginCompleteTypeInfo -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypePluginCompleteTypeInfo -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypePluginCompleteTypeInfo ::
Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) ->
TypePluginCompleteTypeInfo ->
C_TypePluginCompleteTypeInfo
wrap_TypePluginCompleteTypeInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo))
-> TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo
wrap_TypePluginCompleteTypeInfo funptrptr :: Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo))
funptrptr _cb :: TypePluginCompleteTypeInfo
_cb plugin :: Ptr TypePlugin
plugin gType :: CGType
gType info :: Ptr TypeInfo
info valueTable :: Ptr TypeValueTable
valueTable = do
TypePlugin
plugin' <- ((ManagedPtr TypePlugin -> TypePlugin)
-> Ptr TypePlugin -> IO TypePlugin
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypePlugin -> TypePlugin
GObject.TypePlugin.TypePlugin) Ptr TypePlugin
plugin
let gType' :: GType
gType' = CGType -> GType
GType CGType
gType
TypeInfo
info' <- ((ManagedPtr TypeInfo -> TypeInfo) -> Ptr TypeInfo -> IO TypeInfo
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeInfo -> TypeInfo
GObject.TypeInfo.TypeInfo) Ptr TypeInfo
info
TypeValueTable
valueTable' <- ((ManagedPtr TypeValueTable -> TypeValueTable)
-> Ptr TypeValueTable -> IO TypeValueTable
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeValueTable -> TypeValueTable
GObject.TypeValueTable.TypeValueTable) Ptr TypeValueTable
valueTable
TypePluginCompleteTypeInfo
_cb TypePlugin
plugin' GType
gType' TypeInfo
info' TypeValueTable
valueTable'
Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo))
funptrptr
type C_TypePluginCompleteInterfaceInfo =
Ptr GObject.TypePlugin.TypePlugin ->
CGType ->
CGType ->
Ptr GObject.InterfaceInfo.InterfaceInfo ->
IO ()
foreign import ccall "dynamic" __dynamic_C_TypePluginCompleteInterfaceInfo :: FunPtr C_TypePluginCompleteInterfaceInfo -> C_TypePluginCompleteInterfaceInfo
dynamic_TypePluginCompleteInterfaceInfo ::
(B.CallStack.HasCallStack, MonadIO m, GObject.TypePlugin.IsTypePlugin a) =>
FunPtr C_TypePluginCompleteInterfaceInfo
-> a
-> GType
-> GType
-> GObject.InterfaceInfo.InterfaceInfo
-> m ()
dynamic_TypePluginCompleteInterfaceInfo :: FunPtr C_TypePluginCompleteInterfaceInfo
-> a -> GType -> GType -> InterfaceInfo -> m ()
dynamic_TypePluginCompleteInterfaceInfo __funPtr :: FunPtr C_TypePluginCompleteInterfaceInfo
__funPtr plugin :: a
plugin instanceType :: GType
instanceType interfaceType :: GType
interfaceType info :: InterfaceInfo
info = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypePlugin
plugin' <- a -> IO (Ptr TypePlugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
let instanceType' :: CGType
instanceType' = GType -> CGType
gtypeToCGType GType
instanceType
let interfaceType' :: CGType
interfaceType' = GType -> CGType
gtypeToCGType GType
interfaceType
Ptr InterfaceInfo
info' <- InterfaceInfo -> IO (Ptr InterfaceInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr InterfaceInfo
info
(FunPtr C_TypePluginCompleteInterfaceInfo
-> C_TypePluginCompleteInterfaceInfo
__dynamic_C_TypePluginCompleteInterfaceInfo FunPtr C_TypePluginCompleteInterfaceInfo
__funPtr) Ptr TypePlugin
plugin' CGType
instanceType' CGType
interfaceType' Ptr InterfaceInfo
info'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
InterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr InterfaceInfo
info
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo)
type TypePluginCompleteInterfaceInfo =
GObject.TypePlugin.TypePlugin
-> GType
-> GType
-> GObject.InterfaceInfo.InterfaceInfo
-> IO ()
noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo
noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo
noTypePluginCompleteInterfaceInfo = Maybe TypePluginCompleteInterfaceInfo
forall a. Maybe a
Nothing
genClosure_TypePluginCompleteInterfaceInfo :: TypePluginCompleteInterfaceInfo -> IO Closure
genClosure_TypePluginCompleteInterfaceInfo :: TypePluginCompleteInterfaceInfo -> IO Closure
genClosure_TypePluginCompleteInterfaceInfo cb :: TypePluginCompleteInterfaceInfo
cb = do
let cb' :: C_TypePluginCompleteInterfaceInfo
cb' = Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo))
-> TypePluginCompleteInterfaceInfo
-> C_TypePluginCompleteInterfaceInfo
wrap_TypePluginCompleteInterfaceInfo Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo))
forall a. Maybe a
Nothing TypePluginCompleteInterfaceInfo
cb
C_TypePluginCompleteInterfaceInfo
-> IO (FunPtr C_TypePluginCompleteInterfaceInfo)
mk_TypePluginCompleteInterfaceInfo C_TypePluginCompleteInterfaceInfo
cb' IO (FunPtr C_TypePluginCompleteInterfaceInfo)
-> (FunPtr C_TypePluginCompleteInterfaceInfo -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypePluginCompleteInterfaceInfo -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypePluginCompleteInterfaceInfo ::
Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) ->
TypePluginCompleteInterfaceInfo ->
C_TypePluginCompleteInterfaceInfo
wrap_TypePluginCompleteInterfaceInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo))
-> TypePluginCompleteInterfaceInfo
-> C_TypePluginCompleteInterfaceInfo
wrap_TypePluginCompleteInterfaceInfo funptrptr :: Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo))
funptrptr _cb :: TypePluginCompleteInterfaceInfo
_cb plugin :: Ptr TypePlugin
plugin instanceType :: CGType
instanceType interfaceType :: CGType
interfaceType info :: Ptr InterfaceInfo
info = do
TypePlugin
plugin' <- ((ManagedPtr TypePlugin -> TypePlugin)
-> Ptr TypePlugin -> IO TypePlugin
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypePlugin -> TypePlugin
GObject.TypePlugin.TypePlugin) Ptr TypePlugin
plugin
let instanceType' :: GType
instanceType' = CGType -> GType
GType CGType
instanceType
let interfaceType' :: GType
interfaceType' = CGType -> GType
GType CGType
interfaceType
InterfaceInfo
info' <- ((ManagedPtr InterfaceInfo -> InterfaceInfo)
-> Ptr InterfaceInfo -> IO InterfaceInfo
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr InterfaceInfo -> InterfaceInfo
GObject.InterfaceInfo.InterfaceInfo) Ptr InterfaceInfo
info
TypePluginCompleteInterfaceInfo
_cb TypePlugin
plugin' GType
instanceType' GType
interfaceType' InterfaceInfo
info'
Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo))
funptrptr
type C_TypeInterfaceCheckFunc =
Ptr () ->
Ptr GObject.TypeInterface.TypeInterface ->
IO ()
foreign import ccall "dynamic" __dynamic_C_TypeInterfaceCheckFunc :: FunPtr C_TypeInterfaceCheckFunc -> C_TypeInterfaceCheckFunc
dynamic_TypeInterfaceCheckFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TypeInterfaceCheckFunc
-> Ptr ()
-> GObject.TypeInterface.TypeInterface
-> m ()
dynamic_TypeInterfaceCheckFunc :: FunPtr C_TypeInterfaceCheckFunc -> Ptr () -> TypeInterface -> m ()
dynamic_TypeInterfaceCheckFunc __funPtr :: FunPtr C_TypeInterfaceCheckFunc
__funPtr checkData :: Ptr ()
checkData gIface :: TypeInterface
gIface = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeInterface
gIface' <- TypeInterface -> IO (Ptr TypeInterface)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeInterface
gIface
(FunPtr C_TypeInterfaceCheckFunc -> C_TypeInterfaceCheckFunc
__dynamic_C_TypeInterfaceCheckFunc FunPtr C_TypeInterfaceCheckFunc
__funPtr) Ptr ()
checkData Ptr TypeInterface
gIface'
TypeInterface -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeInterface
gIface
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)
type TypeInterfaceCheckFunc =
Ptr ()
-> GObject.TypeInterface.TypeInterface
-> IO ()
noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc
noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc
noTypeInterfaceCheckFunc = Maybe TypeInterfaceCheckFunc
forall a. Maybe a
Nothing
genClosure_TypeInterfaceCheckFunc :: TypeInterfaceCheckFunc -> IO Closure
genClosure_TypeInterfaceCheckFunc :: TypeInterfaceCheckFunc -> IO Closure
genClosure_TypeInterfaceCheckFunc cb :: TypeInterfaceCheckFunc
cb = do
let cb' :: C_TypeInterfaceCheckFunc
cb' = Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc))
-> TypeInterfaceCheckFunc -> C_TypeInterfaceCheckFunc
wrap_TypeInterfaceCheckFunc Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc))
forall a. Maybe a
Nothing TypeInterfaceCheckFunc
cb
C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)
mk_TypeInterfaceCheckFunc C_TypeInterfaceCheckFunc
cb' IO (FunPtr C_TypeInterfaceCheckFunc)
-> (FunPtr C_TypeInterfaceCheckFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypeInterfaceCheckFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypeInterfaceCheckFunc ::
Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc)) ->
TypeInterfaceCheckFunc ->
C_TypeInterfaceCheckFunc
wrap_TypeInterfaceCheckFunc :: Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc))
-> TypeInterfaceCheckFunc -> C_TypeInterfaceCheckFunc
wrap_TypeInterfaceCheckFunc funptrptr :: Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc))
funptrptr _cb :: TypeInterfaceCheckFunc
_cb checkData :: Ptr ()
checkData gIface :: Ptr TypeInterface
gIface = do
TypeInterface
gIface' <- ((ManagedPtr TypeInterface -> TypeInterface)
-> Ptr TypeInterface -> IO TypeInterface
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeInterface -> TypeInterface
GObject.TypeInterface.TypeInterface) Ptr TypeInterface
gIface
TypeInterfaceCheckFunc
_cb Ptr ()
checkData TypeInterface
gIface'
Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc))
funptrptr
type C_TypeClassCacheFunc =
Ptr () ->
Ptr GObject.TypeClass.TypeClass ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_TypeClassCacheFunc :: FunPtr C_TypeClassCacheFunc -> C_TypeClassCacheFunc
dynamic_TypeClassCacheFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_TypeClassCacheFunc
-> Ptr ()
-> GObject.TypeClass.TypeClass
-> m Bool
dynamic_TypeClassCacheFunc :: FunPtr C_TypeClassCacheFunc -> Ptr () -> TypeClass -> m Bool
dynamic_TypeClassCacheFunc __funPtr :: FunPtr C_TypeClassCacheFunc
__funPtr cacheData :: Ptr ()
cacheData gClass :: TypeClass
gClass = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
gClass' <- TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
CInt
result <- (FunPtr C_TypeClassCacheFunc -> C_TypeClassCacheFunc
__dynamic_C_TypeClassCacheFunc FunPtr C_TypeClassCacheFunc
__funPtr) Ptr ()
cacheData Ptr TypeClass
gClass'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)
type TypeClassCacheFunc =
Ptr ()
-> GObject.TypeClass.TypeClass
-> IO Bool
noTypeClassCacheFunc :: Maybe TypeClassCacheFunc
noTypeClassCacheFunc :: Maybe TypeClassCacheFunc
noTypeClassCacheFunc = Maybe TypeClassCacheFunc
forall a. Maybe a
Nothing
genClosure_TypeClassCacheFunc :: TypeClassCacheFunc -> IO Closure
genClosure_TypeClassCacheFunc :: TypeClassCacheFunc -> IO Closure
genClosure_TypeClassCacheFunc cb :: TypeClassCacheFunc
cb = do
let cb' :: C_TypeClassCacheFunc
cb' = Maybe (Ptr (FunPtr C_TypeClassCacheFunc))
-> TypeClassCacheFunc -> C_TypeClassCacheFunc
wrap_TypeClassCacheFunc Maybe (Ptr (FunPtr C_TypeClassCacheFunc))
forall a. Maybe a
Nothing TypeClassCacheFunc
cb
C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)
mk_TypeClassCacheFunc C_TypeClassCacheFunc
cb' IO (FunPtr C_TypeClassCacheFunc)
-> (FunPtr C_TypeClassCacheFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypeClassCacheFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_TypeClassCacheFunc ::
Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) ->
TypeClassCacheFunc ->
C_TypeClassCacheFunc
wrap_TypeClassCacheFunc :: Maybe (Ptr (FunPtr C_TypeClassCacheFunc))
-> TypeClassCacheFunc -> C_TypeClassCacheFunc
wrap_TypeClassCacheFunc funptrptr :: Maybe (Ptr (FunPtr C_TypeClassCacheFunc))
funptrptr _cb :: TypeClassCacheFunc
_cb cacheData :: Ptr ()
cacheData gClass :: Ptr TypeClass
gClass = do
TypeClass
gClass' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
gClass
Bool
result <- TypeClassCacheFunc
_cb Ptr ()
cacheData TypeClass
gClass'
Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypeClassCacheFunc))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_ToggleNotify =
Ptr () ->
Ptr GObject.Object.Object ->
CInt ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ToggleNotify :: FunPtr C_ToggleNotify -> C_ToggleNotify
dynamic_ToggleNotify ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
FunPtr C_ToggleNotify
-> Ptr ()
-> a
-> Bool
-> m ()
dynamic_ToggleNotify :: FunPtr C_ToggleNotify -> Ptr () -> a -> Bool -> m ()
dynamic_ToggleNotify __funPtr :: FunPtr C_ToggleNotify
__funPtr data_ :: Ptr ()
data_ object :: a
object isLastRef :: Bool
isLastRef = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
let isLastRef' :: CInt
isLastRef' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
isLastRef
(FunPtr C_ToggleNotify -> C_ToggleNotify
__dynamic_C_ToggleNotify FunPtr C_ToggleNotify
__funPtr) Ptr ()
data_ Ptr Object
object' CInt
isLastRef'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify)
type ToggleNotify =
Ptr ()
-> GObject.Object.Object
-> Bool
-> IO ()
noToggleNotify :: Maybe ToggleNotify
noToggleNotify :: Maybe ToggleNotify
noToggleNotify = Maybe ToggleNotify
forall a. Maybe a
Nothing
genClosure_ToggleNotify :: ToggleNotify -> IO Closure
genClosure_ToggleNotify :: ToggleNotify -> IO Closure
genClosure_ToggleNotify cb :: ToggleNotify
cb = do
let cb' :: C_ToggleNotify
cb' = Maybe (Ptr (FunPtr C_ToggleNotify))
-> ToggleNotify -> C_ToggleNotify
wrap_ToggleNotify Maybe (Ptr (FunPtr C_ToggleNotify))
forall a. Maybe a
Nothing ToggleNotify
cb
C_ToggleNotify -> IO (FunPtr C_ToggleNotify)
mk_ToggleNotify C_ToggleNotify
cb' IO (FunPtr C_ToggleNotify)
-> (FunPtr C_ToggleNotify -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ToggleNotify -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ToggleNotify ::
Maybe (Ptr (FunPtr C_ToggleNotify)) ->
ToggleNotify ->
C_ToggleNotify
wrap_ToggleNotify :: Maybe (Ptr (FunPtr C_ToggleNotify))
-> ToggleNotify -> C_ToggleNotify
wrap_ToggleNotify funptrptr :: Maybe (Ptr (FunPtr C_ToggleNotify))
funptrptr _cb :: ToggleNotify
_cb data_ :: Ptr ()
data_ object :: Ptr Object
object isLastRef :: CInt
isLastRef = do
Object
object' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
object
let isLastRef' :: Bool
isLastRef' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
isLastRef
ToggleNotify
_cb Ptr ()
data_ Object
object' Bool
isLastRef'
Maybe (Ptr (FunPtr C_ToggleNotify)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ToggleNotify))
funptrptr
type C_SignalEmissionHook =
Ptr GObject.SignalInvocationHint.SignalInvocationHint ->
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_SignalEmissionHook :: FunPtr C_SignalEmissionHook -> C_SignalEmissionHook
dynamic_SignalEmissionHook ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_SignalEmissionHook
-> GObject.SignalInvocationHint.SignalInvocationHint
-> [GValue]
-> Ptr ()
-> m Bool
dynamic_SignalEmissionHook :: FunPtr C_SignalEmissionHook
-> SignalInvocationHint -> [GValue] -> Ptr () -> m Bool
dynamic_SignalEmissionHook __funPtr :: FunPtr C_SignalEmissionHook
__funPtr ihint :: SignalInvocationHint
ihint paramValues :: [GValue]
paramValues data_ :: Ptr ()
data_ = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
let nParamValues :: Word32
nParamValues = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [GValue]
paramValues
Ptr SignalInvocationHint
ihint' <- SignalInvocationHint -> IO (Ptr SignalInvocationHint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SignalInvocationHint
ihint
[Ptr GValue]
paramValues' <- (GValue -> IO (Ptr GValue)) -> [GValue] -> IO [Ptr GValue]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [GValue]
paramValues
Ptr GValue
paramValues'' <- Int -> [Ptr GValue] -> IO (Ptr GValue)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray 24 [Ptr GValue]
paramValues'
CInt
result <- (FunPtr C_SignalEmissionHook -> C_SignalEmissionHook
__dynamic_C_SignalEmissionHook FunPtr C_SignalEmissionHook
__funPtr) Ptr SignalInvocationHint
ihint' Word32
nParamValues Ptr GValue
paramValues'' Ptr ()
data_
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
SignalInvocationHint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SignalInvocationHint
ihint
(GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
paramValues
C_TypeValueTableValueInitFieldCallback
forall a. Ptr a -> IO ()
freeMem Ptr GValue
paramValues''
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)
type SignalEmissionHook =
GObject.SignalInvocationHint.SignalInvocationHint
-> [GValue]
-> Ptr ()
-> IO Bool
noSignalEmissionHook :: Maybe SignalEmissionHook
noSignalEmissionHook :: Maybe SignalEmissionHook
noSignalEmissionHook = Maybe SignalEmissionHook
forall a. Maybe a
Nothing
genClosure_SignalEmissionHook :: SignalEmissionHook -> IO Closure
genClosure_SignalEmissionHook :: SignalEmissionHook -> IO Closure
genClosure_SignalEmissionHook cb :: SignalEmissionHook
cb = do
let cb' :: C_SignalEmissionHook
cb' = Maybe (Ptr (FunPtr C_SignalEmissionHook))
-> SignalEmissionHook -> C_SignalEmissionHook
wrap_SignalEmissionHook Maybe (Ptr (FunPtr C_SignalEmissionHook))
forall a. Maybe a
Nothing SignalEmissionHook
cb
C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)
mk_SignalEmissionHook C_SignalEmissionHook
cb' IO (FunPtr C_SignalEmissionHook)
-> (FunPtr C_SignalEmissionHook -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SignalEmissionHook -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_SignalEmissionHook ::
Maybe (Ptr (FunPtr C_SignalEmissionHook)) ->
SignalEmissionHook ->
C_SignalEmissionHook
wrap_SignalEmissionHook :: Maybe (Ptr (FunPtr C_SignalEmissionHook))
-> SignalEmissionHook -> C_SignalEmissionHook
wrap_SignalEmissionHook funptrptr :: Maybe (Ptr (FunPtr C_SignalEmissionHook))
funptrptr _cb :: SignalEmissionHook
_cb ihint :: Ptr SignalInvocationHint
ihint nParamValues :: Word32
nParamValues paramValues :: Ptr GValue
paramValues data_ :: Ptr ()
data_ = do
SignalInvocationHint
ihint' <- ((ManagedPtr SignalInvocationHint -> SignalInvocationHint)
-> Ptr SignalInvocationHint -> IO SignalInvocationHint
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SignalInvocationHint -> SignalInvocationHint
GObject.SignalInvocationHint.SignalInvocationHint) Ptr SignalInvocationHint
ihint
[Ptr GValue]
paramValues' <- (Int -> Word32 -> Ptr GValue -> IO [Ptr GValue]
forall a b.
(Integral a, BoxedObject b) =>
Int -> a -> Ptr b -> IO [Ptr b]
unpackBoxedArrayWithLength 24 Word32
nParamValues) Ptr GValue
paramValues
[GValue]
paramValues'' <- (Ptr GValue -> IO GValue) -> [Ptr GValue] -> IO [GValue]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr GValue -> GValue) -> Ptr GValue -> IO GValue
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GValue -> GValue
GValue) [Ptr GValue]
paramValues'
Bool
result <- SignalEmissionHook
_cb SignalInvocationHint
ihint' [GValue]
paramValues'' Ptr ()
data_
Maybe (Ptr (FunPtr C_SignalEmissionHook)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_SignalEmissionHook))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_SignalAccumulator =
Ptr GObject.SignalInvocationHint.SignalInvocationHint ->
Ptr GValue ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_SignalAccumulator :: FunPtr C_SignalAccumulator -> C_SignalAccumulator
dynamic_SignalAccumulator ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_SignalAccumulator
-> GObject.SignalInvocationHint.SignalInvocationHint
-> GValue
-> GValue
-> Ptr ()
-> m Bool
dynamic_SignalAccumulator :: FunPtr C_SignalAccumulator
-> SignalInvocationHint -> GValue -> GValue -> Ptr () -> m Bool
dynamic_SignalAccumulator __funPtr :: FunPtr C_SignalAccumulator
__funPtr ihint :: SignalInvocationHint
ihint returnAccu :: GValue
returnAccu handlerReturn :: GValue
handlerReturn data_ :: Ptr ()
data_ = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr SignalInvocationHint
ihint' <- SignalInvocationHint -> IO (Ptr SignalInvocationHint)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SignalInvocationHint
ihint
Ptr GValue
returnAccu' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
returnAccu
Ptr GValue
handlerReturn' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
handlerReturn
CInt
result <- (FunPtr C_SignalAccumulator -> C_SignalAccumulator
__dynamic_C_SignalAccumulator FunPtr C_SignalAccumulator
__funPtr) Ptr SignalInvocationHint
ihint' Ptr GValue
returnAccu' Ptr GValue
handlerReturn' Ptr ()
data_
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
SignalInvocationHint -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SignalInvocationHint
ihint
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
returnAccu
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
handlerReturn
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)
type SignalAccumulator =
GObject.SignalInvocationHint.SignalInvocationHint
-> GValue
-> GValue
-> Ptr ()
-> IO Bool
noSignalAccumulator :: Maybe SignalAccumulator
noSignalAccumulator :: Maybe SignalAccumulator
noSignalAccumulator = Maybe SignalAccumulator
forall a. Maybe a
Nothing
genClosure_SignalAccumulator :: SignalAccumulator -> IO Closure
genClosure_SignalAccumulator :: SignalAccumulator -> IO Closure
genClosure_SignalAccumulator cb :: SignalAccumulator
cb = do
let cb' :: C_SignalAccumulator
cb' = Maybe (Ptr (FunPtr C_SignalAccumulator))
-> SignalAccumulator -> C_SignalAccumulator
wrap_SignalAccumulator Maybe (Ptr (FunPtr C_SignalAccumulator))
forall a. Maybe a
Nothing SignalAccumulator
cb
C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)
mk_SignalAccumulator C_SignalAccumulator
cb' IO (FunPtr C_SignalAccumulator)
-> (FunPtr C_SignalAccumulator -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SignalAccumulator -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_SignalAccumulator ::
Maybe (Ptr (FunPtr C_SignalAccumulator)) ->
SignalAccumulator ->
C_SignalAccumulator
wrap_SignalAccumulator :: Maybe (Ptr (FunPtr C_SignalAccumulator))
-> SignalAccumulator -> C_SignalAccumulator
wrap_SignalAccumulator funptrptr :: Maybe (Ptr (FunPtr C_SignalAccumulator))
funptrptr _cb :: SignalAccumulator
_cb ihint :: Ptr SignalInvocationHint
ihint returnAccu :: Ptr GValue
returnAccu handlerReturn :: Ptr GValue
handlerReturn data_ :: Ptr ()
data_ = do
SignalInvocationHint
ihint' <- ((ManagedPtr SignalInvocationHint -> SignalInvocationHint)
-> Ptr SignalInvocationHint -> IO SignalInvocationHint
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr SignalInvocationHint -> SignalInvocationHint
GObject.SignalInvocationHint.SignalInvocationHint) Ptr SignalInvocationHint
ihint
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
returnAccu ((GValue -> IO CInt) -> IO CInt) -> (GValue -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \returnAccu' :: GValue
returnAccu' -> do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
handlerReturn ((GValue -> IO CInt) -> IO CInt) -> (GValue -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \handlerReturn' :: GValue
handlerReturn' -> do
Bool
result <- SignalAccumulator
_cb SignalInvocationHint
ihint' GValue
returnAccu' GValue
handlerReturn' Ptr ()
data_
Maybe (Ptr (FunPtr C_SignalAccumulator)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_SignalAccumulator))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_ParamSpecTypeInfoValuesCmpFieldCallback =
Ptr GParamSpec ->
Ptr GValue ->
Ptr GValue ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoValuesCmpFieldCallback :: FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> C_ParamSpecTypeInfoValuesCmpFieldCallback
dynamic_ParamSpecTypeInfoValuesCmpFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback
-> GParamSpec
-> GValue
-> GValue
-> m Int32
dynamic_ParamSpecTypeInfoValuesCmpFieldCallback :: FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback
-> GParamSpec -> GValue -> GValue -> m Int32
dynamic_ParamSpecTypeInfoValuesCmpFieldCallback __funPtr :: FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback
__funPtr pspec :: GParamSpec
pspec value1 :: GValue
value1 value2 :: GValue
value2 = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
Ptr GValue
value1' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value1
Ptr GValue
value2' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value2
Int32
result <- (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback
-> C_ParamSpecTypeInfoValuesCmpFieldCallback
__dynamic_C_ParamSpecTypeInfoValuesCmpFieldCallback FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback
__funPtr) Ptr GParamSpec
pspec' Ptr GValue
value1' Ptr GValue
value2'
GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value1
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value2
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)
type ParamSpecTypeInfoValuesCmpFieldCallback =
GParamSpec
-> GValue
-> GValue
-> IO Int32
noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback
noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback
noParamSpecTypeInfoValuesCmpFieldCallback = Maybe ParamSpecTypeInfoValuesCmpFieldCallback
forall a. Maybe a
Nothing
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: ParamSpecTypeInfoValuesCmpFieldCallback -> IO Closure
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: ParamSpecTypeInfoValuesCmpFieldCallback -> IO Closure
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback cb :: ParamSpecTypeInfoValuesCmpFieldCallback
cb = do
let cb' :: C_ParamSpecTypeInfoValuesCmpFieldCallback
cb' = Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback))
-> ParamSpecTypeInfoValuesCmpFieldCallback
-> C_ParamSpecTypeInfoValuesCmpFieldCallback
wrap_ParamSpecTypeInfoValuesCmpFieldCallback Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback))
forall a. Maybe a
Nothing ParamSpecTypeInfoValuesCmpFieldCallback
cb
C_ParamSpecTypeInfoValuesCmpFieldCallback
-> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)
mk_ParamSpecTypeInfoValuesCmpFieldCallback C_ParamSpecTypeInfoValuesCmpFieldCallback
cb' IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)
-> (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ParamSpecTypeInfoValuesCmpFieldCallback ::
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)) ->
ParamSpecTypeInfoValuesCmpFieldCallback ->
C_ParamSpecTypeInfoValuesCmpFieldCallback
wrap_ParamSpecTypeInfoValuesCmpFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback))
-> ParamSpecTypeInfoValuesCmpFieldCallback
-> C_ParamSpecTypeInfoValuesCmpFieldCallback
wrap_ParamSpecTypeInfoValuesCmpFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback))
funptrptr _cb :: ParamSpecTypeInfoValuesCmpFieldCallback
_cb pspec :: Ptr GParamSpec
pspec value1 :: Ptr GValue
value1 value2 :: Ptr GValue
value2 = do
GParamSpec
pspec' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value1 ((GValue -> IO Int32) -> IO Int32)
-> (GValue -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \value1' :: GValue
value1' -> do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO Int32) -> IO Int32
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value2 ((GValue -> IO Int32) -> IO Int32)
-> (GValue -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \value2' :: GValue
value2' -> do
Int32
result <- ParamSpecTypeInfoValuesCmpFieldCallback
_cb GParamSpec
pspec' GValue
value1' GValue
value2'
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_ParamSpecTypeInfoValueValidateFieldCallback =
Ptr GParamSpec ->
Ptr GValue ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoValueValidateFieldCallback :: FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> C_ParamSpecTypeInfoValueValidateFieldCallback
dynamic_ParamSpecTypeInfoValueValidateFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback
-> GParamSpec
-> GValue
-> m Bool
dynamic_ParamSpecTypeInfoValueValidateFieldCallback :: FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback
-> GParamSpec -> GValue -> m Bool
dynamic_ParamSpecTypeInfoValueValidateFieldCallback __funPtr :: FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback
__funPtr pspec :: GParamSpec
pspec value :: GValue
value = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
CInt
result <- (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback
-> C_ParamSpecTypeInfoValueValidateFieldCallback
__dynamic_C_ParamSpecTypeInfoValueValidateFieldCallback FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback
__funPtr) Ptr GParamSpec
pspec' Ptr GValue
value'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)
type ParamSpecTypeInfoValueValidateFieldCallback =
GParamSpec
-> GValue
-> IO Bool
noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback
noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback
noParamSpecTypeInfoValueValidateFieldCallback = Maybe ParamSpecTypeInfoValueValidateFieldCallback
forall a. Maybe a
Nothing
genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: ParamSpecTypeInfoValueValidateFieldCallback -> IO Closure
genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: ParamSpecTypeInfoValueValidateFieldCallback -> IO Closure
genClosure_ParamSpecTypeInfoValueValidateFieldCallback cb :: ParamSpecTypeInfoValueValidateFieldCallback
cb = do
let cb' :: C_ParamSpecTypeInfoValueValidateFieldCallback
cb' = Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback))
-> ParamSpecTypeInfoValueValidateFieldCallback
-> C_ParamSpecTypeInfoValueValidateFieldCallback
wrap_ParamSpecTypeInfoValueValidateFieldCallback Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback))
forall a. Maybe a
Nothing ParamSpecTypeInfoValueValidateFieldCallback
cb
C_ParamSpecTypeInfoValueValidateFieldCallback
-> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)
mk_ParamSpecTypeInfoValueValidateFieldCallback C_ParamSpecTypeInfoValueValidateFieldCallback
cb' IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)
-> (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback
-> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ParamSpecTypeInfoValueValidateFieldCallback ::
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)) ->
ParamSpecTypeInfoValueValidateFieldCallback ->
C_ParamSpecTypeInfoValueValidateFieldCallback
wrap_ParamSpecTypeInfoValueValidateFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback))
-> ParamSpecTypeInfoValueValidateFieldCallback
-> C_ParamSpecTypeInfoValueValidateFieldCallback
wrap_ParamSpecTypeInfoValueValidateFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback))
funptrptr _cb :: ParamSpecTypeInfoValueValidateFieldCallback
_cb pspec :: Ptr GParamSpec
pspec value :: Ptr GValue
value = do
GParamSpec
pspec' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value ((GValue -> IO CInt) -> IO CInt) -> (GValue -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
Bool
result <- ParamSpecTypeInfoValueValidateFieldCallback
_cb GParamSpec
pspec' GValue
value'
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_ParamSpecTypeInfoValueSetDefaultFieldCallback =
Ptr GParamSpec ->
Ptr GValue ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoValueSetDefaultFieldCallback :: FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> C_ParamSpecTypeInfoValueSetDefaultFieldCallback
dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback
-> GParamSpec
-> GValue
-> m ()
dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback :: FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback
-> GParamSpec -> GValue -> m ()
dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback __funPtr :: FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback
__funPtr pspec :: GParamSpec
pspec value :: GValue
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
(FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback
-> C_ParamSpecTypeInfoValueSetDefaultFieldCallback
__dynamic_C_ParamSpecTypeInfoValueSetDefaultFieldCallback FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback
__funPtr) Ptr GParamSpec
pspec' Ptr GValue
value'
GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
type ParamSpecTypeInfoValueSetDefaultFieldCallback =
GParamSpec
-> GValue
-> IO ()
noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback
noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback
noParamSpecTypeInfoValueSetDefaultFieldCallback = Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback
forall a. Maybe a
Nothing
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO Closure
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO Closure
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback cb :: ParamSpecTypeInfoValueSetDefaultFieldCallback
cb = do
let cb' :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback
cb' = Maybe
(Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback))
-> ParamSpecTypeInfoValueSetDefaultFieldCallback
-> C_ParamSpecTypeInfoValueSetDefaultFieldCallback
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback Maybe
(Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback))
forall a. Maybe a
Nothing ParamSpecTypeInfoValueSetDefaultFieldCallback
cb
C_ParamSpecTypeInfoValueSetDefaultFieldCallback
-> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
mk_ParamSpecTypeInfoValueSetDefaultFieldCallback C_ParamSpecTypeInfoValueSetDefaultFieldCallback
cb' IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
-> (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback
-> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback
-> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback ::
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)) ->
ParamSpecTypeInfoValueSetDefaultFieldCallback ->
C_ParamSpecTypeInfoValueSetDefaultFieldCallback
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe
(Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback))
-> ParamSpecTypeInfoValueSetDefaultFieldCallback
-> C_ParamSpecTypeInfoValueSetDefaultFieldCallback
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback funptrptr :: Maybe
(Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback))
funptrptr _cb :: ParamSpecTypeInfoValueSetDefaultFieldCallback
_cb pspec :: Ptr GParamSpec
pspec value :: Ptr GValue
value = do
GParamSpec
pspec' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
ParamSpecTypeInfoValueSetDefaultFieldCallback
_cb GParamSpec
pspec' GValue
value'
Maybe
(Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe
(Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback))
funptrptr
type C_ParamSpecTypeInfoInstanceInitFieldCallback =
Ptr GParamSpec ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoInstanceInitFieldCallback :: FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> C_ParamSpecTypeInfoInstanceInitFieldCallback
dynamic_ParamSpecTypeInfoInstanceInitFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
-> GParamSpec
-> m ()
dynamic_ParamSpecTypeInfoInstanceInitFieldCallback :: FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
-> GParamSpec -> m ()
dynamic_ParamSpecTypeInfoInstanceInitFieldCallback __funPtr :: FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
__funPtr pspec :: GParamSpec
pspec = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
(FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
-> C_ParamSpecTypeInfoInstanceInitFieldCallback
__dynamic_C_ParamSpecTypeInfoInstanceInitFieldCallback FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
__funPtr) Ptr GParamSpec
pspec'
GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)
type ParamSpecTypeInfoInstanceInitFieldCallback =
GParamSpec
-> IO ()
noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback
noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe (GParamSpec -> IO ())
noParamSpecTypeInfoInstanceInitFieldCallback = Maybe (GParamSpec -> IO ())
forall a. Maybe a
Nothing
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: ParamSpecTypeInfoInstanceInitFieldCallback -> IO Closure
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: (GParamSpec -> IO ()) -> IO Closure
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback cb :: GParamSpec -> IO ()
cb = do
let cb' :: C_ParamSpecTypeInfoInstanceInitFieldCallback
cb' = Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
-> (GParamSpec -> IO ())
-> C_ParamSpecTypeInfoInstanceInitFieldCallback
wrap_ParamSpecTypeInfoInstanceInitFieldCallback Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
forall a. Maybe a
Nothing GParamSpec -> IO ()
cb
C_ParamSpecTypeInfoInstanceInitFieldCallback
-> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)
mk_ParamSpecTypeInfoInstanceInitFieldCallback C_ParamSpecTypeInfoInstanceInitFieldCallback
cb' IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)
-> (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
-> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ParamSpecTypeInfoInstanceInitFieldCallback ::
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)) ->
ParamSpecTypeInfoInstanceInitFieldCallback ->
C_ParamSpecTypeInfoInstanceInitFieldCallback
wrap_ParamSpecTypeInfoInstanceInitFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
-> (GParamSpec -> IO ())
-> C_ParamSpecTypeInfoInstanceInitFieldCallback
wrap_ParamSpecTypeInfoInstanceInitFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
funptrptr _cb :: GParamSpec -> IO ()
_cb pspec :: Ptr GParamSpec
pspec = do
GParamSpec
pspec' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec
GParamSpec -> IO ()
_cb GParamSpec
pspec'
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
funptrptr
type C_ParamSpecTypeInfoFinalizeFieldCallback =
Ptr GParamSpec ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoFinalizeFieldCallback :: FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> C_ParamSpecTypeInfoFinalizeFieldCallback
dynamic_ParamSpecTypeInfoFinalizeFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback
-> GParamSpec
-> m ()
dynamic_ParamSpecTypeInfoFinalizeFieldCallback :: FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
-> GParamSpec -> m ()
dynamic_ParamSpecTypeInfoFinalizeFieldCallback __funPtr :: FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
__funPtr pspec :: GParamSpec
pspec = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
(FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
-> C_ParamSpecTypeInfoInstanceInitFieldCallback
__dynamic_C_ParamSpecTypeInfoFinalizeFieldCallback FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
__funPtr) Ptr GParamSpec
pspec'
GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)
type ParamSpecTypeInfoFinalizeFieldCallback =
GParamSpec
-> IO ()
noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback
noParamSpecTypeInfoFinalizeFieldCallback :: Maybe (GParamSpec -> IO ())
noParamSpecTypeInfoFinalizeFieldCallback = Maybe (GParamSpec -> IO ())
forall a. Maybe a
Nothing
genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: ParamSpecTypeInfoFinalizeFieldCallback -> IO Closure
genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: (GParamSpec -> IO ()) -> IO Closure
genClosure_ParamSpecTypeInfoFinalizeFieldCallback cb :: GParamSpec -> IO ()
cb = do
let cb' :: C_ParamSpecTypeInfoInstanceInitFieldCallback
cb' = Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
-> (GParamSpec -> IO ())
-> C_ParamSpecTypeInfoInstanceInitFieldCallback
wrap_ParamSpecTypeInfoFinalizeFieldCallback Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
forall a. Maybe a
Nothing GParamSpec -> IO ()
cb
C_ParamSpecTypeInfoInstanceInitFieldCallback
-> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)
mk_ParamSpecTypeInfoFinalizeFieldCallback C_ParamSpecTypeInfoInstanceInitFieldCallback
cb' IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)
-> (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
-> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ParamSpecTypeInfoFinalizeFieldCallback ::
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)) ->
ParamSpecTypeInfoFinalizeFieldCallback ->
C_ParamSpecTypeInfoFinalizeFieldCallback
wrap_ParamSpecTypeInfoFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
-> (GParamSpec -> IO ())
-> C_ParamSpecTypeInfoInstanceInitFieldCallback
wrap_ParamSpecTypeInfoFinalizeFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
funptrptr _cb :: GParamSpec -> IO ()
_cb pspec :: Ptr GParamSpec
pspec = do
GParamSpec
pspec' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec
GParamSpec -> IO ()
_cb GParamSpec
pspec'
Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
-> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback))
funptrptr
type C_ObjectSetPropertyFunc =
Ptr GObject.Object.Object ->
Word32 ->
Ptr GValue ->
Ptr GParamSpec ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ObjectSetPropertyFunc :: FunPtr C_ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
dynamic_ObjectSetPropertyFunc ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
FunPtr C_ObjectSetPropertyFunc
-> a
-> Word32
-> GValue
-> GParamSpec
-> m ()
dynamic_ObjectSetPropertyFunc :: FunPtr C_ObjectSetPropertyFunc
-> a -> Word32 -> GValue -> GParamSpec -> m ()
dynamic_ObjectSetPropertyFunc __funPtr :: FunPtr C_ObjectSetPropertyFunc
__funPtr object :: a
object propertyId :: Word32
propertyId value :: GValue
value pspec :: GParamSpec
pspec = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
(FunPtr C_ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
__dynamic_C_ObjectSetPropertyFunc FunPtr C_ObjectSetPropertyFunc
__funPtr) Ptr Object
object' Word32
propertyId Ptr GValue
value' Ptr GParamSpec
pspec'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)
type ObjectSetPropertyFunc =
GObject.Object.Object
-> Word32
-> GValue
-> GParamSpec
-> IO ()
noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc
noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc
noObjectSetPropertyFunc = Maybe ObjectSetPropertyFunc
forall a. Maybe a
Nothing
genClosure_ObjectSetPropertyFunc :: ObjectSetPropertyFunc -> IO Closure
genClosure_ObjectSetPropertyFunc :: ObjectSetPropertyFunc -> IO Closure
genClosure_ObjectSetPropertyFunc cb :: ObjectSetPropertyFunc
cb = do
let cb' :: C_ObjectSetPropertyFunc
cb' = Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
-> ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
wrap_ObjectSetPropertyFunc Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
forall a. Maybe a
Nothing ObjectSetPropertyFunc
cb
C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)
mk_ObjectSetPropertyFunc C_ObjectSetPropertyFunc
cb' IO (FunPtr C_ObjectSetPropertyFunc)
-> (FunPtr C_ObjectSetPropertyFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ObjectSetPropertyFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ObjectSetPropertyFunc ::
Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) ->
ObjectSetPropertyFunc ->
C_ObjectSetPropertyFunc
wrap_ObjectSetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
-> ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
wrap_ObjectSetPropertyFunc funptrptr :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
funptrptr _cb :: ObjectSetPropertyFunc
_cb object :: Ptr Object
object propertyId :: Word32
propertyId value :: Ptr GValue
value pspec :: Ptr GParamSpec
pspec = do
Object
object' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
object
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
GParamSpec
pspec' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec
ObjectSetPropertyFunc
_cb Object
object' Word32
propertyId GValue
value' GParamSpec
pspec'
Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
funptrptr
type C_ObjectGetPropertyFunc =
Ptr GObject.Object.Object ->
Word32 ->
Ptr GValue ->
Ptr GParamSpec ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ObjectGetPropertyFunc :: FunPtr C_ObjectGetPropertyFunc -> C_ObjectGetPropertyFunc
dynamic_ObjectGetPropertyFunc ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
FunPtr C_ObjectGetPropertyFunc
-> a
-> Word32
-> GValue
-> GParamSpec
-> m ()
dynamic_ObjectGetPropertyFunc :: FunPtr C_ObjectSetPropertyFunc
-> a -> Word32 -> GValue -> GParamSpec -> m ()
dynamic_ObjectGetPropertyFunc __funPtr :: FunPtr C_ObjectSetPropertyFunc
__funPtr object :: a
object propertyId :: Word32
propertyId value :: GValue
value pspec :: GParamSpec
pspec = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
(FunPtr C_ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
__dynamic_C_ObjectGetPropertyFunc FunPtr C_ObjectSetPropertyFunc
__funPtr) Ptr Object
object' Word32
propertyId Ptr GValue
value' Ptr GParamSpec
pspec'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc)
type ObjectGetPropertyFunc =
GObject.Object.Object
-> Word32
-> GValue
-> GParamSpec
-> IO ()
noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc
noObjectGetPropertyFunc :: Maybe ObjectSetPropertyFunc
noObjectGetPropertyFunc = Maybe ObjectSetPropertyFunc
forall a. Maybe a
Nothing
genClosure_ObjectGetPropertyFunc :: ObjectGetPropertyFunc -> IO Closure
genClosure_ObjectGetPropertyFunc :: ObjectSetPropertyFunc -> IO Closure
genClosure_ObjectGetPropertyFunc cb :: ObjectSetPropertyFunc
cb = do
let cb' :: C_ObjectSetPropertyFunc
cb' = Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
-> ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
wrap_ObjectGetPropertyFunc Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
forall a. Maybe a
Nothing ObjectSetPropertyFunc
cb
C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)
mk_ObjectGetPropertyFunc C_ObjectSetPropertyFunc
cb' IO (FunPtr C_ObjectSetPropertyFunc)
-> (FunPtr C_ObjectSetPropertyFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ObjectSetPropertyFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ObjectGetPropertyFunc ::
Maybe (Ptr (FunPtr C_ObjectGetPropertyFunc)) ->
ObjectGetPropertyFunc ->
C_ObjectGetPropertyFunc
wrap_ObjectGetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
-> ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
wrap_ObjectGetPropertyFunc funptrptr :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
funptrptr _cb :: ObjectSetPropertyFunc
_cb object :: Ptr Object
object propertyId :: Word32
propertyId value :: Ptr GValue
value pspec :: Ptr GParamSpec
pspec = do
Object
object' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
object
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
value ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \value' :: GValue
value' -> do
GParamSpec
pspec' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec
ObjectSetPropertyFunc
_cb Object
object' Word32
propertyId GValue
value' GParamSpec
pspec'
Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc))
funptrptr
type C_ObjectFinalizeFunc =
Ptr GObject.Object.Object ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ObjectFinalizeFunc :: FunPtr C_ObjectFinalizeFunc -> C_ObjectFinalizeFunc
dynamic_ObjectFinalizeFunc ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
FunPtr C_ObjectFinalizeFunc
-> a
-> m ()
dynamic_ObjectFinalizeFunc :: FunPtr C_ObjectFinalizeFunc -> a -> m ()
dynamic_ObjectFinalizeFunc __funPtr :: FunPtr C_ObjectFinalizeFunc
__funPtr object :: a
object = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
(FunPtr C_ObjectFinalizeFunc -> C_ObjectFinalizeFunc
__dynamic_C_ObjectFinalizeFunc FunPtr C_ObjectFinalizeFunc
__funPtr) Ptr Object
object'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)
type ObjectFinalizeFunc =
GObject.Object.Object
-> IO ()
noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc
noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc
noObjectFinalizeFunc = Maybe ObjectFinalizeFunc
forall a. Maybe a
Nothing
genClosure_ObjectFinalizeFunc :: ObjectFinalizeFunc -> IO Closure
genClosure_ObjectFinalizeFunc :: ObjectFinalizeFunc -> IO Closure
genClosure_ObjectFinalizeFunc cb :: ObjectFinalizeFunc
cb = do
let cb' :: C_ObjectFinalizeFunc
cb' = Maybe (Ptr (FunPtr C_ObjectFinalizeFunc))
-> ObjectFinalizeFunc -> C_ObjectFinalizeFunc
wrap_ObjectFinalizeFunc Maybe (Ptr (FunPtr C_ObjectFinalizeFunc))
forall a. Maybe a
Nothing ObjectFinalizeFunc
cb
C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)
mk_ObjectFinalizeFunc C_ObjectFinalizeFunc
cb' IO (FunPtr C_ObjectFinalizeFunc)
-> (FunPtr C_ObjectFinalizeFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ObjectFinalizeFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ObjectFinalizeFunc ::
Maybe (Ptr (FunPtr C_ObjectFinalizeFunc)) ->
ObjectFinalizeFunc ->
C_ObjectFinalizeFunc
wrap_ObjectFinalizeFunc :: Maybe (Ptr (FunPtr C_ObjectFinalizeFunc))
-> ObjectFinalizeFunc -> C_ObjectFinalizeFunc
wrap_ObjectFinalizeFunc funptrptr :: Maybe (Ptr (FunPtr C_ObjectFinalizeFunc))
funptrptr _cb :: ObjectFinalizeFunc
_cb object :: Ptr Object
object = do
Object
object' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
object
ObjectFinalizeFunc
_cb Object
object'
Maybe (Ptr (FunPtr C_ObjectFinalizeFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ObjectFinalizeFunc))
funptrptr
type C_InterfaceInitFunc =
Ptr GObject.TypeInterface.TypeInterface ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_InterfaceInitFunc :: FunPtr C_InterfaceInitFunc -> C_InterfaceInitFunc
dynamic_InterfaceInitFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_InterfaceInitFunc
-> GObject.TypeInterface.TypeInterface
-> Ptr ()
-> m ()
dynamic_InterfaceInitFunc :: FunPtr C_InterfaceInitFunc -> TypeInterface -> Ptr () -> m ()
dynamic_InterfaceInitFunc __funPtr :: FunPtr C_InterfaceInitFunc
__funPtr gIface :: TypeInterface
gIface ifaceData :: Ptr ()
ifaceData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeInterface
gIface' <- TypeInterface -> IO (Ptr TypeInterface)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeInterface
gIface
(FunPtr C_InterfaceInitFunc -> C_InterfaceInitFunc
__dynamic_C_InterfaceInitFunc FunPtr C_InterfaceInitFunc
__funPtr) Ptr TypeInterface
gIface' Ptr ()
ifaceData
TypeInterface -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeInterface
gIface
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)
type InterfaceInitFunc =
GObject.TypeInterface.TypeInterface
-> Ptr ()
-> IO ()
noInterfaceInitFunc :: Maybe InterfaceInitFunc
noInterfaceInitFunc :: Maybe InterfaceInitFunc
noInterfaceInitFunc = Maybe InterfaceInitFunc
forall a. Maybe a
Nothing
genClosure_InterfaceInitFunc :: InterfaceInitFunc -> IO Closure
genClosure_InterfaceInitFunc :: InterfaceInitFunc -> IO Closure
genClosure_InterfaceInitFunc cb :: InterfaceInitFunc
cb = do
let cb' :: C_InterfaceInitFunc
cb' = Maybe (Ptr (FunPtr C_InterfaceInitFunc))
-> InterfaceInitFunc -> C_InterfaceInitFunc
wrap_InterfaceInitFunc Maybe (Ptr (FunPtr C_InterfaceInitFunc))
forall a. Maybe a
Nothing InterfaceInitFunc
cb
C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)
mk_InterfaceInitFunc C_InterfaceInitFunc
cb' IO (FunPtr C_InterfaceInitFunc)
-> (FunPtr C_InterfaceInitFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InterfaceInitFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_InterfaceInitFunc ::
Maybe (Ptr (FunPtr C_InterfaceInitFunc)) ->
InterfaceInitFunc ->
C_InterfaceInitFunc
wrap_InterfaceInitFunc :: Maybe (Ptr (FunPtr C_InterfaceInitFunc))
-> InterfaceInitFunc -> C_InterfaceInitFunc
wrap_InterfaceInitFunc funptrptr :: Maybe (Ptr (FunPtr C_InterfaceInitFunc))
funptrptr _cb :: InterfaceInitFunc
_cb gIface :: Ptr TypeInterface
gIface ifaceData :: Ptr ()
ifaceData = do
TypeInterface
gIface' <- ((ManagedPtr TypeInterface -> TypeInterface)
-> Ptr TypeInterface -> IO TypeInterface
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeInterface -> TypeInterface
GObject.TypeInterface.TypeInterface) Ptr TypeInterface
gIface
InterfaceInitFunc
_cb TypeInterface
gIface' Ptr ()
ifaceData
Maybe (Ptr (FunPtr C_InterfaceInitFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_InterfaceInitFunc))
funptrptr
type C_InterfaceFinalizeFunc =
Ptr GObject.TypeInterface.TypeInterface ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_InterfaceFinalizeFunc :: FunPtr C_InterfaceFinalizeFunc -> C_InterfaceFinalizeFunc
dynamic_InterfaceFinalizeFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_InterfaceFinalizeFunc
-> GObject.TypeInterface.TypeInterface
-> Ptr ()
-> m ()
dynamic_InterfaceFinalizeFunc :: FunPtr C_InterfaceInitFunc -> TypeInterface -> Ptr () -> m ()
dynamic_InterfaceFinalizeFunc __funPtr :: FunPtr C_InterfaceInitFunc
__funPtr gIface :: TypeInterface
gIface ifaceData :: Ptr ()
ifaceData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeInterface
gIface' <- TypeInterface -> IO (Ptr TypeInterface)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeInterface
gIface
(FunPtr C_InterfaceInitFunc -> C_InterfaceInitFunc
__dynamic_C_InterfaceFinalizeFunc FunPtr C_InterfaceInitFunc
__funPtr) Ptr TypeInterface
gIface' Ptr ()
ifaceData
TypeInterface -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeInterface
gIface
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc)
type InterfaceFinalizeFunc =
GObject.TypeInterface.TypeInterface
-> Ptr ()
-> IO ()
noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc
noInterfaceFinalizeFunc :: Maybe InterfaceInitFunc
noInterfaceFinalizeFunc = Maybe InterfaceInitFunc
forall a. Maybe a
Nothing
genClosure_InterfaceFinalizeFunc :: InterfaceFinalizeFunc -> IO Closure
genClosure_InterfaceFinalizeFunc :: InterfaceInitFunc -> IO Closure
genClosure_InterfaceFinalizeFunc cb :: InterfaceInitFunc
cb = do
let cb' :: C_InterfaceInitFunc
cb' = Maybe (Ptr (FunPtr C_InterfaceInitFunc))
-> InterfaceInitFunc -> C_InterfaceInitFunc
wrap_InterfaceFinalizeFunc Maybe (Ptr (FunPtr C_InterfaceInitFunc))
forall a. Maybe a
Nothing InterfaceInitFunc
cb
C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)
mk_InterfaceFinalizeFunc C_InterfaceInitFunc
cb' IO (FunPtr C_InterfaceInitFunc)
-> (FunPtr C_InterfaceInitFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InterfaceInitFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_InterfaceFinalizeFunc ::
Maybe (Ptr (FunPtr C_InterfaceFinalizeFunc)) ->
InterfaceFinalizeFunc ->
C_InterfaceFinalizeFunc
wrap_InterfaceFinalizeFunc :: Maybe (Ptr (FunPtr C_InterfaceInitFunc))
-> InterfaceInitFunc -> C_InterfaceInitFunc
wrap_InterfaceFinalizeFunc funptrptr :: Maybe (Ptr (FunPtr C_InterfaceInitFunc))
funptrptr _cb :: InterfaceInitFunc
_cb gIface :: Ptr TypeInterface
gIface ifaceData :: Ptr ()
ifaceData = do
TypeInterface
gIface' <- ((ManagedPtr TypeInterface -> TypeInterface)
-> Ptr TypeInterface -> IO TypeInterface
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeInterface -> TypeInterface
GObject.TypeInterface.TypeInterface) Ptr TypeInterface
gIface
InterfaceInitFunc
_cb TypeInterface
gIface' Ptr ()
ifaceData
Maybe (Ptr (FunPtr C_InterfaceInitFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_InterfaceInitFunc))
funptrptr
type C_InstanceInitFunc =
Ptr GObject.TypeInstance.TypeInstance ->
Ptr GObject.TypeClass.TypeClass ->
IO ()
foreign import ccall "dynamic" __dynamic_C_InstanceInitFunc :: FunPtr C_InstanceInitFunc -> C_InstanceInitFunc
dynamic_InstanceInitFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_InstanceInitFunc
-> GObject.TypeInstance.TypeInstance
-> GObject.TypeClass.TypeClass
-> m ()
dynamic_InstanceInitFunc :: FunPtr C_InstanceInitFunc -> TypeInstance -> TypeClass -> m ()
dynamic_InstanceInitFunc __funPtr :: FunPtr C_InstanceInitFunc
__funPtr instance_ :: TypeInstance
instance_ gClass :: TypeClass
gClass = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeInstance
instance_' <- TypeInstance -> IO (Ptr TypeInstance)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeInstance
instance_
Ptr TypeClass
gClass' <- TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
(FunPtr C_InstanceInitFunc -> C_InstanceInitFunc
__dynamic_C_InstanceInitFunc FunPtr C_InstanceInitFunc
__funPtr) Ptr TypeInstance
instance_' Ptr TypeClass
gClass'
TypeInstance -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeInstance
instance_
TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)
type InstanceInitFunc =
GObject.TypeInstance.TypeInstance
-> GObject.TypeClass.TypeClass
-> IO ()
noInstanceInitFunc :: Maybe InstanceInitFunc
noInstanceInitFunc :: Maybe InstanceInitFunc
noInstanceInitFunc = Maybe InstanceInitFunc
forall a. Maybe a
Nothing
genClosure_InstanceInitFunc :: InstanceInitFunc -> IO Closure
genClosure_InstanceInitFunc :: InstanceInitFunc -> IO Closure
genClosure_InstanceInitFunc cb :: InstanceInitFunc
cb = do
let cb' :: C_InstanceInitFunc
cb' = Maybe (Ptr (FunPtr C_InstanceInitFunc))
-> InstanceInitFunc -> C_InstanceInitFunc
wrap_InstanceInitFunc Maybe (Ptr (FunPtr C_InstanceInitFunc))
forall a. Maybe a
Nothing InstanceInitFunc
cb
C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)
mk_InstanceInitFunc C_InstanceInitFunc
cb' IO (FunPtr C_InstanceInitFunc)
-> (FunPtr C_InstanceInitFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InstanceInitFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_InstanceInitFunc ::
Maybe (Ptr (FunPtr C_InstanceInitFunc)) ->
InstanceInitFunc ->
C_InstanceInitFunc
wrap_InstanceInitFunc :: Maybe (Ptr (FunPtr C_InstanceInitFunc))
-> InstanceInitFunc -> C_InstanceInitFunc
wrap_InstanceInitFunc funptrptr :: Maybe (Ptr (FunPtr C_InstanceInitFunc))
funptrptr _cb :: InstanceInitFunc
_cb instance_ :: Ptr TypeInstance
instance_ gClass :: Ptr TypeClass
gClass = do
TypeInstance
instance_' <- ((ManagedPtr TypeInstance -> TypeInstance)
-> Ptr TypeInstance -> IO TypeInstance
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeInstance -> TypeInstance
GObject.TypeInstance.TypeInstance) Ptr TypeInstance
instance_
TypeClass
gClass' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
gClass
InstanceInitFunc
_cb TypeInstance
instance_' TypeClass
gClass'
Maybe (Ptr (FunPtr C_InstanceInitFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_InstanceInitFunc))
funptrptr
type C_ClosureNotify =
Ptr () ->
Ptr Closure ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ClosureNotify :: FunPtr C_ClosureNotify -> C_ClosureNotify
dynamic_ClosureNotify ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ClosureNotify
-> Ptr ()
-> Closure
-> m ()
dynamic_ClosureNotify :: FunPtr C_ClosureNotify -> Ptr () -> Closure -> m ()
dynamic_ClosureNotify __funPtr :: FunPtr C_ClosureNotify
__funPtr data_ :: Ptr ()
data_ closure :: Closure
closure = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Closure
closure' <- Closure -> IO (Ptr Closure)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Closure
closure
(FunPtr C_ClosureNotify -> C_ClosureNotify
__dynamic_C_ClosureNotify FunPtr C_ClosureNotify
__funPtr) Ptr ()
data_ Ptr Closure
closure'
Closure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Closure
closure
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify)
type ClosureNotify =
Ptr ()
-> Closure
-> IO ()
noClosureNotify :: Maybe ClosureNotify
noClosureNotify :: Maybe ClosureNotify
noClosureNotify = Maybe ClosureNotify
forall a. Maybe a
Nothing
genClosure_ClosureNotify :: ClosureNotify -> IO Closure
genClosure_ClosureNotify :: ClosureNotify -> IO Closure
genClosure_ClosureNotify cb :: ClosureNotify
cb = do
let cb' :: C_ClosureNotify
cb' = Maybe (Ptr (FunPtr C_ClosureNotify))
-> ClosureNotify -> C_ClosureNotify
wrap_ClosureNotify Maybe (Ptr (FunPtr C_ClosureNotify))
forall a. Maybe a
Nothing ClosureNotify
cb
C_ClosureNotify -> IO (FunPtr C_ClosureNotify)
mk_ClosureNotify C_ClosureNotify
cb' IO (FunPtr C_ClosureNotify)
-> (FunPtr C_ClosureNotify -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClosureNotify -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ClosureNotify ::
Maybe (Ptr (FunPtr C_ClosureNotify)) ->
ClosureNotify ->
C_ClosureNotify
wrap_ClosureNotify :: Maybe (Ptr (FunPtr C_ClosureNotify))
-> ClosureNotify -> C_ClosureNotify
wrap_ClosureNotify funptrptr :: Maybe (Ptr (FunPtr C_ClosureNotify))
funptrptr _cb :: ClosureNotify
_cb data_ :: Ptr ()
data_ closure :: Ptr Closure
closure = do
(ManagedPtr Closure -> Closure)
-> Ptr Closure -> (Closure -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Closure -> Closure
Closure Ptr Closure
closure ((Closure -> IO ()) -> IO ()) -> (Closure -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \closure' :: Closure
closure' -> do
ClosureNotify
_cb Ptr ()
data_ Closure
closure'
Maybe (Ptr (FunPtr C_ClosureNotify)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClosureNotify))
funptrptr
type C_ClosureMarshalFieldCallback =
Ptr Closure ->
Ptr GValue ->
Word32 ->
Ptr GValue ->
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ClosureMarshalFieldCallback :: FunPtr C_ClosureMarshalFieldCallback -> C_ClosureMarshalFieldCallback
dynamic_ClosureMarshalFieldCallback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ClosureMarshalFieldCallback
-> Closure
-> GValue
-> Word32
-> GValue
-> Ptr ()
-> Ptr ()
-> m ()
dynamic_ClosureMarshalFieldCallback :: FunPtr C_ClosureMarshalFieldCallback
-> Closure
-> GValue
-> Word32
-> GValue
-> Ptr ()
-> Ptr ()
-> m ()
dynamic_ClosureMarshalFieldCallback __funPtr :: FunPtr C_ClosureMarshalFieldCallback
__funPtr closure :: Closure
closure returnValue :: GValue
returnValue nParamValues :: Word32
nParamValues paramValues :: GValue
paramValues invocationHint :: Ptr ()
invocationHint marshalData :: Ptr ()
marshalData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Closure
closure' <- Closure -> IO (Ptr Closure)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Closure
closure
Ptr GValue
returnValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
returnValue
Ptr GValue
paramValues' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
paramValues
(FunPtr C_ClosureMarshalFieldCallback
-> C_ClosureMarshalFieldCallback
__dynamic_C_ClosureMarshalFieldCallback FunPtr C_ClosureMarshalFieldCallback
__funPtr) Ptr Closure
closure' Ptr GValue
returnValue' Word32
nParamValues Ptr GValue
paramValues' Ptr ()
invocationHint Ptr ()
marshalData
Closure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Closure
closure
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
returnValue
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
paramValues
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback)
type ClosureMarshalFieldCallback =
Closure
-> GValue
-> Word32
-> GValue
-> Ptr ()
-> Ptr ()
-> IO ()
noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback
noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback
noClosureMarshalFieldCallback = Maybe ClosureMarshalFieldCallback
forall a. Maybe a
Nothing
genClosure_ClosureMarshalFieldCallback :: ClosureMarshalFieldCallback -> IO Closure
genClosure_ClosureMarshalFieldCallback :: ClosureMarshalFieldCallback -> IO Closure
genClosure_ClosureMarshalFieldCallback cb :: ClosureMarshalFieldCallback
cb = do
let cb' :: C_ClosureMarshalFieldCallback
cb' = Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback))
-> ClosureMarshalFieldCallback -> C_ClosureMarshalFieldCallback
wrap_ClosureMarshalFieldCallback Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback))
forall a. Maybe a
Nothing ClosureMarshalFieldCallback
cb
C_ClosureMarshalFieldCallback
-> IO (FunPtr C_ClosureMarshalFieldCallback)
mk_ClosureMarshalFieldCallback C_ClosureMarshalFieldCallback
cb' IO (FunPtr C_ClosureMarshalFieldCallback)
-> (FunPtr C_ClosureMarshalFieldCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClosureMarshalFieldCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ClosureMarshalFieldCallback ::
Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) ->
ClosureMarshalFieldCallback ->
C_ClosureMarshalFieldCallback
wrap_ClosureMarshalFieldCallback :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback))
-> ClosureMarshalFieldCallback -> C_ClosureMarshalFieldCallback
wrap_ClosureMarshalFieldCallback funptrptr :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback))
funptrptr _cb :: ClosureMarshalFieldCallback
_cb closure :: Ptr Closure
closure returnValue :: Ptr GValue
returnValue nParamValues :: Word32
nParamValues paramValues :: Ptr GValue
paramValues invocationHint :: Ptr ()
invocationHint marshalData :: Ptr ()
marshalData = do
(ManagedPtr Closure -> Closure)
-> Ptr Closure -> (Closure -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Closure -> Closure
Closure Ptr Closure
closure ((Closure -> IO ()) -> IO ()) -> (Closure -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \closure' :: Closure
closure' -> do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
returnValue ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \returnValue' :: GValue
returnValue' -> do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
paramValues ((GValue -> IO ()) -> IO ()) -> (GValue -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \paramValues' :: GValue
paramValues' -> do
ClosureMarshalFieldCallback
_cb Closure
closure' GValue
returnValue' Word32
nParamValues GValue
paramValues' Ptr ()
invocationHint Ptr ()
marshalData
Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback))
funptrptr
type C_ClassInitFunc =
Ptr GObject.TypeClass.TypeClass ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ClassInitFunc :: FunPtr C_ClassInitFunc -> C_ClassInitFunc
dynamic_ClassInitFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ClassInitFunc
-> GObject.TypeClass.TypeClass
-> Ptr ()
-> m ()
dynamic_ClassInitFunc :: FunPtr C_ClassInitFunc -> TypeClass -> Ptr () -> m ()
dynamic_ClassInitFunc __funPtr :: FunPtr C_ClassInitFunc
__funPtr gClass :: TypeClass
gClass classData :: Ptr ()
classData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
gClass' <- TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
(FunPtr C_ClassInitFunc -> C_ClassInitFunc
__dynamic_C_ClassInitFunc FunPtr C_ClassInitFunc
__funPtr) Ptr TypeClass
gClass' Ptr ()
classData
TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)
type ClassInitFunc =
GObject.TypeClass.TypeClass
-> Ptr ()
-> IO ()
noClassInitFunc :: Maybe ClassInitFunc
noClassInitFunc :: Maybe ClassInitFunc
noClassInitFunc = Maybe ClassInitFunc
forall a. Maybe a
Nothing
genClosure_ClassInitFunc :: ClassInitFunc -> IO Closure
genClosure_ClassInitFunc :: ClassInitFunc -> IO Closure
genClosure_ClassInitFunc cb :: ClassInitFunc
cb = do
let cb' :: C_ClassInitFunc
cb' = Maybe (Ptr (FunPtr C_ClassInitFunc))
-> ClassInitFunc -> C_ClassInitFunc
wrap_ClassInitFunc Maybe (Ptr (FunPtr C_ClassInitFunc))
forall a. Maybe a
Nothing ClassInitFunc
cb
C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)
mk_ClassInitFunc C_ClassInitFunc
cb' IO (FunPtr C_ClassInitFunc)
-> (FunPtr C_ClassInitFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClassInitFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ClassInitFunc ::
Maybe (Ptr (FunPtr C_ClassInitFunc)) ->
ClassInitFunc ->
C_ClassInitFunc
wrap_ClassInitFunc :: Maybe (Ptr (FunPtr C_ClassInitFunc))
-> ClassInitFunc -> C_ClassInitFunc
wrap_ClassInitFunc funptrptr :: Maybe (Ptr (FunPtr C_ClassInitFunc))
funptrptr _cb :: ClassInitFunc
_cb gClass :: Ptr TypeClass
gClass classData :: Ptr ()
classData = do
TypeClass
gClass' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
gClass
ClassInitFunc
_cb TypeClass
gClass' Ptr ()
classData
Maybe (Ptr (FunPtr C_ClassInitFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClassInitFunc))
funptrptr
type C_ClassFinalizeFunc =
Ptr GObject.TypeClass.TypeClass ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_ClassFinalizeFunc :: FunPtr C_ClassFinalizeFunc -> C_ClassFinalizeFunc
dynamic_ClassFinalizeFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_ClassFinalizeFunc
-> GObject.TypeClass.TypeClass
-> Ptr ()
-> m ()
dynamic_ClassFinalizeFunc :: FunPtr C_ClassInitFunc -> TypeClass -> Ptr () -> m ()
dynamic_ClassFinalizeFunc __funPtr :: FunPtr C_ClassInitFunc
__funPtr gClass :: TypeClass
gClass classData :: Ptr ()
classData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
gClass' <- TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
(FunPtr C_ClassInitFunc -> C_ClassInitFunc
__dynamic_C_ClassFinalizeFunc FunPtr C_ClassInitFunc
__funPtr) Ptr TypeClass
gClass' Ptr ()
classData
TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc)
type ClassFinalizeFunc =
GObject.TypeClass.TypeClass
-> Ptr ()
-> IO ()
noClassFinalizeFunc :: Maybe ClassFinalizeFunc
noClassFinalizeFunc :: Maybe ClassInitFunc
noClassFinalizeFunc = Maybe ClassInitFunc
forall a. Maybe a
Nothing
genClosure_ClassFinalizeFunc :: ClassFinalizeFunc -> IO Closure
genClosure_ClassFinalizeFunc :: ClassInitFunc -> IO Closure
genClosure_ClassFinalizeFunc cb :: ClassInitFunc
cb = do
let cb' :: C_ClassInitFunc
cb' = Maybe (Ptr (FunPtr C_ClassInitFunc))
-> ClassInitFunc -> C_ClassInitFunc
wrap_ClassFinalizeFunc Maybe (Ptr (FunPtr C_ClassInitFunc))
forall a. Maybe a
Nothing ClassInitFunc
cb
C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)
mk_ClassFinalizeFunc C_ClassInitFunc
cb' IO (FunPtr C_ClassInitFunc)
-> (FunPtr C_ClassInitFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ClassInitFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_ClassFinalizeFunc ::
Maybe (Ptr (FunPtr C_ClassFinalizeFunc)) ->
ClassFinalizeFunc ->
C_ClassFinalizeFunc
wrap_ClassFinalizeFunc :: Maybe (Ptr (FunPtr C_ClassInitFunc))
-> ClassInitFunc -> C_ClassInitFunc
wrap_ClassFinalizeFunc funptrptr :: Maybe (Ptr (FunPtr C_ClassInitFunc))
funptrptr _cb :: ClassInitFunc
_cb gClass :: Ptr TypeClass
gClass classData :: Ptr ()
classData = do
TypeClass
gClass' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
gClass
ClassInitFunc
_cb TypeClass
gClass' Ptr ()
classData
Maybe (Ptr (FunPtr C_ClassInitFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ClassInitFunc))
funptrptr
type C_Callback =
IO ()
foreign import ccall "dynamic" __dynamic_C_Callback :: FunPtr C_Callback -> C_Callback
dynamic_Callback ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_Callback
-> m ()
dynamic_Callback :: FunPtr (IO ()) -> m ()
dynamic_Callback __funPtr :: FunPtr (IO ())
__funPtr = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
(FunPtr (IO ()) -> IO ()
__dynamic_C_Callback FunPtr (IO ())
__funPtr)
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_Callback :: C_Callback -> IO (FunPtr C_Callback)
type Callback =
IO ()
noCallback :: Maybe Callback
noCallback :: Maybe (IO ())
noCallback = Maybe (IO ())
forall a. Maybe a
Nothing
genClosure_Callback :: Callback -> IO Closure
genClosure_Callback :: IO () -> IO Closure
genClosure_Callback cb :: IO ()
cb = do
let cb' :: IO ()
cb' = Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
wrap_Callback Maybe (Ptr (FunPtr (IO ())))
forall a. Maybe a
Nothing IO ()
cb
IO () -> IO (FunPtr (IO ()))
mk_Callback IO ()
cb' IO (FunPtr (IO ())) -> (FunPtr (IO ()) -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr (IO ()) -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_Callback ::
Maybe (Ptr (FunPtr C_Callback)) ->
Callback ->
C_Callback
wrap_Callback :: Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
wrap_Callback funptrptr :: Maybe (Ptr (FunPtr (IO ())))
funptrptr _cb :: IO ()
_cb = do
IO ()
_cb
Maybe (Ptr (FunPtr (IO ()))) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr (IO ())))
funptrptr
type C_BoxedFreeFunc =
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_BoxedFreeFunc :: FunPtr C_BoxedFreeFunc -> C_BoxedFreeFunc
dynamic_BoxedFreeFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_BoxedFreeFunc
-> Ptr ()
-> m ()
dynamic_BoxedFreeFunc :: FunPtr C_BoxedFreeFunc -> Ptr () -> m ()
dynamic_BoxedFreeFunc __funPtr :: FunPtr C_BoxedFreeFunc
__funPtr boxed :: Ptr ()
boxed = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
(FunPtr C_BoxedFreeFunc -> C_BoxedFreeFunc
__dynamic_C_BoxedFreeFunc FunPtr C_BoxedFreeFunc
__funPtr) Ptr ()
boxed
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)
type BoxedFreeFunc =
Ptr ()
-> IO ()
noBoxedFreeFunc :: Maybe BoxedFreeFunc
noBoxedFreeFunc :: Maybe C_BoxedFreeFunc
noBoxedFreeFunc = Maybe C_BoxedFreeFunc
forall a. Maybe a
Nothing
genClosure_BoxedFreeFunc :: BoxedFreeFunc -> IO Closure
genClosure_BoxedFreeFunc :: C_BoxedFreeFunc -> IO Closure
genClosure_BoxedFreeFunc cb :: C_BoxedFreeFunc
cb = do
let cb' :: C_BoxedFreeFunc
cb' = Maybe (Ptr (FunPtr C_BoxedFreeFunc))
-> C_BoxedFreeFunc -> C_BoxedFreeFunc
wrap_BoxedFreeFunc Maybe (Ptr (FunPtr C_BoxedFreeFunc))
forall a. Maybe a
Nothing C_BoxedFreeFunc
cb
C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)
mk_BoxedFreeFunc C_BoxedFreeFunc
cb' IO (FunPtr C_BoxedFreeFunc)
-> (FunPtr C_BoxedFreeFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BoxedFreeFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_BoxedFreeFunc ::
Maybe (Ptr (FunPtr C_BoxedFreeFunc)) ->
BoxedFreeFunc ->
C_BoxedFreeFunc
wrap_BoxedFreeFunc :: Maybe (Ptr (FunPtr C_BoxedFreeFunc))
-> C_BoxedFreeFunc -> C_BoxedFreeFunc
wrap_BoxedFreeFunc funptrptr :: Maybe (Ptr (FunPtr C_BoxedFreeFunc))
funptrptr _cb :: C_BoxedFreeFunc
_cb boxed :: Ptr ()
boxed = do
C_BoxedFreeFunc
_cb Ptr ()
boxed
Maybe (Ptr (FunPtr C_BoxedFreeFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_BoxedFreeFunc))
funptrptr
type C_BoxedCopyFunc =
Ptr () ->
IO (Ptr ())
foreign import ccall "dynamic" __dynamic_C_BoxedCopyFunc :: FunPtr C_BoxedCopyFunc -> C_BoxedCopyFunc
dynamic_BoxedCopyFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_BoxedCopyFunc
-> Ptr ()
-> m (Ptr ())
dynamic_BoxedCopyFunc :: FunPtr (Ptr () -> IO (Ptr ())) -> Ptr () -> m (Ptr ())
dynamic_BoxedCopyFunc __funPtr :: FunPtr (Ptr () -> IO (Ptr ()))
__funPtr boxed :: Ptr ()
boxed = 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
$ do
Ptr ()
result <- (FunPtr (Ptr () -> IO (Ptr ())) -> Ptr () -> IO (Ptr ())
__dynamic_C_BoxedCopyFunc FunPtr (Ptr () -> IO (Ptr ()))
__funPtr) Ptr ()
boxed
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
foreign import ccall "wrapper"
mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc)
type BoxedCopyFunc =
Ptr ()
-> IO (Ptr ())
noBoxedCopyFunc :: Maybe BoxedCopyFunc
noBoxedCopyFunc :: Maybe (Ptr () -> IO (Ptr ()))
noBoxedCopyFunc = Maybe (Ptr () -> IO (Ptr ()))
forall a. Maybe a
Nothing
genClosure_BoxedCopyFunc :: BoxedCopyFunc -> IO Closure
genClosure_BoxedCopyFunc :: (Ptr () -> IO (Ptr ())) -> IO Closure
genClosure_BoxedCopyFunc cb :: Ptr () -> IO (Ptr ())
cb = do
let cb' :: Ptr () -> IO (Ptr ())
cb' = Maybe (Ptr (FunPtr (Ptr () -> IO (Ptr ()))))
-> (Ptr () -> IO (Ptr ())) -> Ptr () -> IO (Ptr ())
wrap_BoxedCopyFunc Maybe (Ptr (FunPtr (Ptr () -> IO (Ptr ()))))
forall a. Maybe a
Nothing Ptr () -> IO (Ptr ())
cb
(Ptr () -> IO (Ptr ())) -> IO (FunPtr (Ptr () -> IO (Ptr ())))
mk_BoxedCopyFunc Ptr () -> IO (Ptr ())
cb' IO (FunPtr (Ptr () -> IO (Ptr ())))
-> (FunPtr (Ptr () -> IO (Ptr ())) -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr (Ptr () -> IO (Ptr ())) -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_BoxedCopyFunc ::
Maybe (Ptr (FunPtr C_BoxedCopyFunc)) ->
BoxedCopyFunc ->
C_BoxedCopyFunc
wrap_BoxedCopyFunc :: Maybe (Ptr (FunPtr (Ptr () -> IO (Ptr ()))))
-> (Ptr () -> IO (Ptr ())) -> Ptr () -> IO (Ptr ())
wrap_BoxedCopyFunc funptrptr :: Maybe (Ptr (FunPtr (Ptr () -> IO (Ptr ()))))
funptrptr _cb :: Ptr () -> IO (Ptr ())
_cb boxed :: Ptr ()
boxed = do
Ptr ()
result <- Ptr () -> IO (Ptr ())
_cb Ptr ()
boxed
Maybe (Ptr (FunPtr (Ptr () -> IO (Ptr ())))) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr (Ptr () -> IO (Ptr ()))))
funptrptr
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
type C_BindingTransformFunc =
Ptr GObject.Binding.Binding ->
Ptr GValue ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_BindingTransformFunc :: FunPtr C_BindingTransformFunc -> C_BindingTransformFunc
dynamic_BindingTransformFunc ::
(B.CallStack.HasCallStack, MonadIO m, GObject.Binding.IsBinding a) =>
FunPtr C_BindingTransformFunc
-> a
-> GValue
-> GValue
-> Ptr ()
-> m Bool
dynamic_BindingTransformFunc :: FunPtr C_BindingTransformFunc
-> a -> GValue -> GValue -> Ptr () -> m Bool
dynamic_BindingTransformFunc __funPtr :: FunPtr C_BindingTransformFunc
__funPtr binding :: a
binding fromValue :: GValue
fromValue toValue :: GValue
toValue userData :: Ptr ()
userData = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Binding
binding' <- a -> IO (Ptr Binding)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
binding
Ptr GValue
fromValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
fromValue
Ptr GValue
toValue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
toValue
CInt
result <- (FunPtr C_BindingTransformFunc -> C_BindingTransformFunc
__dynamic_C_BindingTransformFunc FunPtr C_BindingTransformFunc
__funPtr) Ptr Binding
binding' Ptr GValue
fromValue' Ptr GValue
toValue' Ptr ()
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
binding
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
fromValue
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
toValue
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)
type BindingTransformFunc =
GObject.Binding.Binding
-> GValue
-> GValue
-> IO Bool
noBindingTransformFunc :: Maybe BindingTransformFunc
noBindingTransformFunc :: Maybe BindingTransformFunc
noBindingTransformFunc = Maybe BindingTransformFunc
forall a. Maybe a
Nothing
type BindingTransformFunc_WithClosures =
GObject.Binding.Binding
-> GValue
-> GValue
-> Ptr ()
-> IO Bool
noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures
noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures
noBindingTransformFunc_WithClosures = Maybe BindingTransformFunc_WithClosures
forall a. Maybe a
Nothing
drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures
drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures
drop_closures_BindingTransformFunc _f :: BindingTransformFunc
_f binding :: Binding
binding fromValue :: GValue
fromValue toValue :: GValue
toValue _ = BindingTransformFunc
_f Binding
binding GValue
fromValue GValue
toValue
genClosure_BindingTransformFunc :: BindingTransformFunc -> IO Closure
genClosure_BindingTransformFunc :: BindingTransformFunc -> IO Closure
genClosure_BindingTransformFunc cb :: BindingTransformFunc
cb = do
let cb' :: BindingTransformFunc_WithClosures
cb' = BindingTransformFunc -> BindingTransformFunc_WithClosures
drop_closures_BindingTransformFunc BindingTransformFunc
cb
let cb'' :: C_BindingTransformFunc
cb'' = Maybe (Ptr (FunPtr C_BindingTransformFunc))
-> BindingTransformFunc_WithClosures -> C_BindingTransformFunc
wrap_BindingTransformFunc Maybe (Ptr (FunPtr C_BindingTransformFunc))
forall a. Maybe a
Nothing BindingTransformFunc_WithClosures
cb'
C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)
mk_BindingTransformFunc C_BindingTransformFunc
cb'' IO (FunPtr C_BindingTransformFunc)
-> (FunPtr C_BindingTransformFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BindingTransformFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_BindingTransformFunc ::
Maybe (Ptr (FunPtr C_BindingTransformFunc)) ->
BindingTransformFunc_WithClosures ->
C_BindingTransformFunc
wrap_BindingTransformFunc :: Maybe (Ptr (FunPtr C_BindingTransformFunc))
-> BindingTransformFunc_WithClosures -> C_BindingTransformFunc
wrap_BindingTransformFunc funptrptr :: Maybe (Ptr (FunPtr C_BindingTransformFunc))
funptrptr _cb :: BindingTransformFunc_WithClosures
_cb binding :: Ptr Binding
binding fromValue :: Ptr GValue
fromValue toValue :: Ptr GValue
toValue userData :: Ptr ()
userData = do
Binding
binding' <- ((ManagedPtr Binding -> Binding) -> Ptr Binding -> IO Binding
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Binding -> Binding
GObject.Binding.Binding) Ptr Binding
binding
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
fromValue ((GValue -> IO CInt) -> IO CInt) -> (GValue -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \fromValue' :: GValue
fromValue' -> do
(ManagedPtr GValue -> GValue)
-> Ptr GValue -> (GValue -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr GValue -> GValue
GValue Ptr GValue
toValue ((GValue -> IO CInt) -> IO CInt) -> (GValue -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \toValue' :: GValue
toValue' -> do
Bool
result <- BindingTransformFunc_WithClosures
_cb Binding
binding' GValue
fromValue' GValue
toValue' Ptr ()
userData
Maybe (Ptr (FunPtr C_BindingTransformFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_BindingTransformFunc))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_BaseInitFunc =
Ptr GObject.TypeClass.TypeClass ->
IO ()
foreign import ccall "dynamic" __dynamic_C_BaseInitFunc :: FunPtr C_BaseInitFunc -> C_BaseInitFunc
dynamic_BaseInitFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_BaseInitFunc
-> GObject.TypeClass.TypeClass
-> m ()
dynamic_BaseInitFunc :: FunPtr C_BaseInitFunc -> TypeClass -> m ()
dynamic_BaseInitFunc __funPtr :: FunPtr C_BaseInitFunc
__funPtr gClass :: TypeClass
gClass = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
gClass' <- TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
(FunPtr C_BaseInitFunc -> C_BaseInitFunc
__dynamic_C_BaseInitFunc FunPtr C_BaseInitFunc
__funPtr) Ptr TypeClass
gClass'
TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)
type BaseInitFunc =
GObject.TypeClass.TypeClass
-> IO ()
noBaseInitFunc :: Maybe BaseInitFunc
noBaseInitFunc :: Maybe (TypeClass -> IO ())
noBaseInitFunc = Maybe (TypeClass -> IO ())
forall a. Maybe a
Nothing
genClosure_BaseInitFunc :: BaseInitFunc -> IO Closure
genClosure_BaseInitFunc :: (TypeClass -> IO ()) -> IO Closure
genClosure_BaseInitFunc cb :: TypeClass -> IO ()
cb = do
let cb' :: C_BaseInitFunc
cb' = Maybe (Ptr (FunPtr C_BaseInitFunc))
-> (TypeClass -> IO ()) -> C_BaseInitFunc
wrap_BaseInitFunc Maybe (Ptr (FunPtr C_BaseInitFunc))
forall a. Maybe a
Nothing TypeClass -> IO ()
cb
C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)
mk_BaseInitFunc C_BaseInitFunc
cb' IO (FunPtr C_BaseInitFunc)
-> (FunPtr C_BaseInitFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BaseInitFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_BaseInitFunc ::
Maybe (Ptr (FunPtr C_BaseInitFunc)) ->
BaseInitFunc ->
C_BaseInitFunc
wrap_BaseInitFunc :: Maybe (Ptr (FunPtr C_BaseInitFunc))
-> (TypeClass -> IO ()) -> C_BaseInitFunc
wrap_BaseInitFunc funptrptr :: Maybe (Ptr (FunPtr C_BaseInitFunc))
funptrptr _cb :: TypeClass -> IO ()
_cb gClass :: Ptr TypeClass
gClass = do
TypeClass
gClass' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
gClass
TypeClass -> IO ()
_cb TypeClass
gClass'
Maybe (Ptr (FunPtr C_BaseInitFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_BaseInitFunc))
funptrptr
type C_BaseFinalizeFunc =
Ptr GObject.TypeClass.TypeClass ->
IO ()
foreign import ccall "dynamic" __dynamic_C_BaseFinalizeFunc :: FunPtr C_BaseFinalizeFunc -> C_BaseFinalizeFunc
dynamic_BaseFinalizeFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_BaseFinalizeFunc
-> GObject.TypeClass.TypeClass
-> m ()
dynamic_BaseFinalizeFunc :: FunPtr C_BaseInitFunc -> TypeClass -> m ()
dynamic_BaseFinalizeFunc __funPtr :: FunPtr C_BaseInitFunc
__funPtr gClass :: TypeClass
gClass = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
gClass' <- TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
(FunPtr C_BaseInitFunc -> C_BaseInitFunc
__dynamic_C_BaseFinalizeFunc FunPtr C_BaseInitFunc
__funPtr) Ptr TypeClass
gClass'
TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc)
type BaseFinalizeFunc =
GObject.TypeClass.TypeClass
-> IO ()
noBaseFinalizeFunc :: Maybe BaseFinalizeFunc
noBaseFinalizeFunc :: Maybe (TypeClass -> IO ())
noBaseFinalizeFunc = Maybe (TypeClass -> IO ())
forall a. Maybe a
Nothing
genClosure_BaseFinalizeFunc :: BaseFinalizeFunc -> IO Closure
genClosure_BaseFinalizeFunc :: (TypeClass -> IO ()) -> IO Closure
genClosure_BaseFinalizeFunc cb :: TypeClass -> IO ()
cb = do
let cb' :: C_BaseInitFunc
cb' = Maybe (Ptr (FunPtr C_BaseInitFunc))
-> (TypeClass -> IO ()) -> C_BaseInitFunc
wrap_BaseFinalizeFunc Maybe (Ptr (FunPtr C_BaseInitFunc))
forall a. Maybe a
Nothing TypeClass -> IO ()
cb
C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)
mk_BaseFinalizeFunc C_BaseInitFunc
cb' IO (FunPtr C_BaseInitFunc)
-> (FunPtr C_BaseInitFunc -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BaseInitFunc -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure
wrap_BaseFinalizeFunc ::
Maybe (Ptr (FunPtr C_BaseFinalizeFunc)) ->
BaseFinalizeFunc ->
C_BaseFinalizeFunc
wrap_BaseFinalizeFunc :: Maybe (Ptr (FunPtr C_BaseInitFunc))
-> (TypeClass -> IO ()) -> C_BaseInitFunc
wrap_BaseFinalizeFunc funptrptr :: Maybe (Ptr (FunPtr C_BaseInitFunc))
funptrptr _cb :: TypeClass -> IO ()
_cb gClass :: Ptr TypeClass
gClass = do
TypeClass
gClass' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
gClass
TypeClass -> IO ()
_cb TypeClass
gClass'
Maybe (Ptr (FunPtr C_BaseInitFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_BaseInitFunc))
funptrptr