module GI.GObject.Callbacks
(
BaseFinalizeFunc ,
BaseFinalizeFuncC ,
baseFinalizeFuncClosure ,
baseFinalizeFuncWrapper ,
mkBaseFinalizeFunc ,
noBaseFinalizeFunc ,
BaseInitFunc ,
BaseInitFuncC ,
baseInitFuncClosure ,
baseInitFuncWrapper ,
mkBaseInitFunc ,
noBaseInitFunc ,
BindingTransformFunc ,
BindingTransformFuncC ,
bindingTransformFuncClosure ,
bindingTransformFuncWrapper ,
mkBindingTransformFunc ,
noBindingTransformFunc ,
BoxedFreeFunc ,
BoxedFreeFuncC ,
boxedFreeFuncClosure ,
boxedFreeFuncWrapper ,
mkBoxedFreeFunc ,
noBoxedFreeFunc ,
Callback ,
CallbackC ,
callbackClosure ,
callbackWrapper ,
mkCallback ,
noCallback ,
ClassFinalizeFunc ,
ClassFinalizeFuncC ,
classFinalizeFuncClosure ,
classFinalizeFuncWrapper ,
mkClassFinalizeFunc ,
noClassFinalizeFunc ,
ClassInitFunc ,
ClassInitFuncC ,
classInitFuncClosure ,
classInitFuncWrapper ,
mkClassInitFunc ,
noClassInitFunc ,
ClosureMarshalFieldCallback ,
ClosureMarshalFieldCallbackC ,
closureMarshalFieldCallbackClosure ,
closureMarshalFieldCallbackWrapper ,
mkClosureMarshalFieldCallback ,
noClosureMarshalFieldCallback ,
ClosureNotify ,
ClosureNotifyC ,
closureNotifyClosure ,
closureNotifyWrapper ,
mkClosureNotify ,
noClosureNotify ,
InstanceInitFunc ,
InstanceInitFuncC ,
instanceInitFuncClosure ,
instanceInitFuncWrapper ,
mkInstanceInitFunc ,
noInstanceInitFunc ,
InterfaceFinalizeFunc ,
InterfaceFinalizeFuncC ,
interfaceFinalizeFuncClosure ,
interfaceFinalizeFuncWrapper ,
mkInterfaceFinalizeFunc ,
noInterfaceFinalizeFunc ,
InterfaceInitFunc ,
InterfaceInitFuncC ,
interfaceInitFuncClosure ,
interfaceInitFuncWrapper ,
mkInterfaceInitFunc ,
noInterfaceInitFunc ,
ObjectFinalizeFunc ,
ObjectFinalizeFuncC ,
mkObjectFinalizeFunc ,
noObjectFinalizeFunc ,
objectFinalizeFuncClosure ,
objectFinalizeFuncWrapper ,
ObjectGetPropertyFunc ,
ObjectGetPropertyFuncC ,
mkObjectGetPropertyFunc ,
noObjectGetPropertyFunc ,
objectGetPropertyFuncClosure ,
objectGetPropertyFuncWrapper ,
ObjectSetPropertyFunc ,
ObjectSetPropertyFuncC ,
mkObjectSetPropertyFunc ,
noObjectSetPropertyFunc ,
objectSetPropertyFuncClosure ,
objectSetPropertyFuncWrapper ,
ParamSpecTypeInfoFinalizeFieldCallback ,
ParamSpecTypeInfoFinalizeFieldCallbackC ,
mkParamSpecTypeInfoFinalizeFieldCallback,
noParamSpecTypeInfoFinalizeFieldCallback,
paramSpecTypeInfoFinalizeFieldCallbackClosure,
paramSpecTypeInfoFinalizeFieldCallbackWrapper,
ParamSpecTypeInfoInstanceInitFieldCallback,
ParamSpecTypeInfoInstanceInitFieldCallbackC,
mkParamSpecTypeInfoInstanceInitFieldCallback,
noParamSpecTypeInfoInstanceInitFieldCallback,
paramSpecTypeInfoInstanceInitFieldCallbackClosure,
paramSpecTypeInfoInstanceInitFieldCallbackWrapper,
ParamSpecTypeInfoValueSetDefaultFieldCallback,
ParamSpecTypeInfoValueSetDefaultFieldCallbackC,
mkParamSpecTypeInfoValueSetDefaultFieldCallback,
noParamSpecTypeInfoValueSetDefaultFieldCallback,
paramSpecTypeInfoValueSetDefaultFieldCallbackClosure,
paramSpecTypeInfoValueSetDefaultFieldCallbackWrapper,
ParamSpecTypeInfoValueValidateFieldCallback,
ParamSpecTypeInfoValueValidateFieldCallbackC,
mkParamSpecTypeInfoValueValidateFieldCallback,
noParamSpecTypeInfoValueValidateFieldCallback,
paramSpecTypeInfoValueValidateFieldCallbackClosure,
paramSpecTypeInfoValueValidateFieldCallbackWrapper,
ParamSpecTypeInfoValuesCmpFieldCallback ,
ParamSpecTypeInfoValuesCmpFieldCallbackC,
mkParamSpecTypeInfoValuesCmpFieldCallback,
noParamSpecTypeInfoValuesCmpFieldCallback,
paramSpecTypeInfoValuesCmpFieldCallbackClosure,
paramSpecTypeInfoValuesCmpFieldCallbackWrapper,
SignalAccumulator ,
SignalAccumulatorC ,
mkSignalAccumulator ,
noSignalAccumulator ,
signalAccumulatorClosure ,
signalAccumulatorWrapper ,
SignalEmissionHook ,
SignalEmissionHookC ,
mkSignalEmissionHook ,
noSignalEmissionHook ,
signalEmissionHookClosure ,
signalEmissionHookWrapper ,
ToggleNotify ,
ToggleNotifyC ,
mkToggleNotify ,
noToggleNotify ,
toggleNotifyClosure ,
toggleNotifyWrapper ,
TypeClassCacheFunc ,
TypeClassCacheFuncC ,
mkTypeClassCacheFunc ,
noTypeClassCacheFunc ,
typeClassCacheFuncClosure ,
typeClassCacheFuncWrapper ,
TypeInterfaceCheckFunc ,
TypeInterfaceCheckFuncC ,
mkTypeInterfaceCheckFunc ,
noTypeInterfaceCheckFunc ,
typeInterfaceCheckFuncClosure ,
typeInterfaceCheckFuncWrapper ,
TypeValueTableCollectValueFieldCallback ,
TypeValueTableCollectValueFieldCallbackC,
mkTypeValueTableCollectValueFieldCallback,
noTypeValueTableCollectValueFieldCallback,
typeValueTableCollectValueFieldCallbackClosure,
typeValueTableCollectValueFieldCallbackWrapper,
TypeValueTableLcopyValueFieldCallback ,
TypeValueTableLcopyValueFieldCallbackC ,
mkTypeValueTableLcopyValueFieldCallback ,
noTypeValueTableLcopyValueFieldCallback ,
typeValueTableLcopyValueFieldCallbackClosure,
typeValueTableLcopyValueFieldCallbackWrapper,
TypeValueTableValueCopyFieldCallback ,
TypeValueTableValueCopyFieldCallbackC ,
mkTypeValueTableValueCopyFieldCallback ,
noTypeValueTableValueCopyFieldCallback ,
typeValueTableValueCopyFieldCallbackClosure,
typeValueTableValueCopyFieldCallbackWrapper,
TypeValueTableValueFreeFieldCallback ,
TypeValueTableValueFreeFieldCallbackC ,
mkTypeValueTableValueFreeFieldCallback ,
noTypeValueTableValueFreeFieldCallback ,
typeValueTableValueFreeFieldCallbackClosure,
typeValueTableValueFreeFieldCallbackWrapper,
TypeValueTableValueInitFieldCallback ,
TypeValueTableValueInitFieldCallbackC ,
mkTypeValueTableValueInitFieldCallback ,
noTypeValueTableValueInitFieldCallback ,
typeValueTableValueInitFieldCallbackClosure,
typeValueTableValueInitFieldCallbackWrapper,
ValueTransform ,
ValueTransformC ,
mkValueTransform ,
noValueTransform ,
valueTransformClosure ,
valueTransformWrapper ,
WeakNotify ,
WeakNotifyC ,
mkWeakNotify ,
noWeakNotify ,
weakNotifyClosure ,
weakNotifyWrapper ,
) where
import Prelude ()
import Data.GI.Base.ShortPrelude
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import GI.GObject.Types
weakNotifyClosure :: WeakNotify -> IO Closure
weakNotifyClosure cb = newCClosure =<< mkWeakNotify wrapped
where wrapped = weakNotifyWrapper Nothing cb
type WeakNotifyC =
Ptr () ->
Ptr Object ->
IO ()
foreign import ccall "wrapper"
mkWeakNotify :: WeakNotifyC -> IO (FunPtr WeakNotifyC)
type WeakNotify =
Ptr () ->
Object ->
IO ()
noWeakNotify :: Maybe WeakNotify
noWeakNotify = Nothing
weakNotifyWrapper ::
Maybe (Ptr (FunPtr (WeakNotifyC))) ->
WeakNotify ->
Ptr () ->
Ptr Object ->
IO ()
weakNotifyWrapper funptrptr _cb data_ where_the_object_was = do
where_the_object_was' <- (newObject Object) where_the_object_was
_cb data_ where_the_object_was'
maybeReleaseFunPtr funptrptr
valueTransformClosure :: ValueTransform -> IO Closure
valueTransformClosure cb = newCClosure =<< mkValueTransform wrapped
where wrapped = valueTransformWrapper Nothing cb
type ValueTransformC =
Ptr GValue ->
Ptr GValue ->
IO ()
foreign import ccall "wrapper"
mkValueTransform :: ValueTransformC -> IO (FunPtr ValueTransformC)
type ValueTransform =
GValue ->
GValue ->
IO ()
noValueTransform :: Maybe ValueTransform
noValueTransform = Nothing
valueTransformWrapper ::
Maybe (Ptr (FunPtr (ValueTransformC))) ->
ValueTransform ->
Ptr GValue ->
Ptr GValue ->
IO ()
valueTransformWrapper funptrptr _cb src_value dest_value = do
src_value' <- (newBoxed GValue) src_value
dest_value' <- (newBoxed GValue) dest_value
_cb src_value' dest_value'
maybeReleaseFunPtr funptrptr
typeValueTableValueInitFieldCallbackClosure :: TypeValueTableValueInitFieldCallback -> IO Closure
typeValueTableValueInitFieldCallbackClosure cb = newCClosure =<< mkTypeValueTableValueInitFieldCallback wrapped
where wrapped = typeValueTableValueInitFieldCallbackWrapper Nothing cb
type TypeValueTableValueInitFieldCallbackC =
Ptr GValue ->
IO ()
foreign import ccall "wrapper"
mkTypeValueTableValueInitFieldCallback :: TypeValueTableValueInitFieldCallbackC -> IO (FunPtr TypeValueTableValueInitFieldCallbackC)
type TypeValueTableValueInitFieldCallback =
GValue ->
IO ()
noTypeValueTableValueInitFieldCallback :: Maybe TypeValueTableValueInitFieldCallback
noTypeValueTableValueInitFieldCallback = Nothing
typeValueTableValueInitFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (TypeValueTableValueInitFieldCallbackC))) ->
TypeValueTableValueInitFieldCallback ->
Ptr GValue ->
IO ()
typeValueTableValueInitFieldCallbackWrapper funptrptr _cb value = do
value' <- (newBoxed GValue) value
_cb value'
maybeReleaseFunPtr funptrptr
typeValueTableValueFreeFieldCallbackClosure :: TypeValueTableValueFreeFieldCallback -> IO Closure
typeValueTableValueFreeFieldCallbackClosure cb = newCClosure =<< mkTypeValueTableValueFreeFieldCallback wrapped
where wrapped = typeValueTableValueFreeFieldCallbackWrapper Nothing cb
type TypeValueTableValueFreeFieldCallbackC =
Ptr GValue ->
IO ()
foreign import ccall "wrapper"
mkTypeValueTableValueFreeFieldCallback :: TypeValueTableValueFreeFieldCallbackC -> IO (FunPtr TypeValueTableValueFreeFieldCallbackC)
type TypeValueTableValueFreeFieldCallback =
GValue ->
IO ()
noTypeValueTableValueFreeFieldCallback :: Maybe TypeValueTableValueFreeFieldCallback
noTypeValueTableValueFreeFieldCallback = Nothing
typeValueTableValueFreeFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (TypeValueTableValueFreeFieldCallbackC))) ->
TypeValueTableValueFreeFieldCallback ->
Ptr GValue ->
IO ()
typeValueTableValueFreeFieldCallbackWrapper funptrptr _cb value = do
value' <- (newBoxed GValue) value
_cb value'
maybeReleaseFunPtr funptrptr
typeValueTableValueCopyFieldCallbackClosure :: TypeValueTableValueCopyFieldCallback -> IO Closure
typeValueTableValueCopyFieldCallbackClosure cb = newCClosure =<< mkTypeValueTableValueCopyFieldCallback wrapped
where wrapped = typeValueTableValueCopyFieldCallbackWrapper Nothing cb
type TypeValueTableValueCopyFieldCallbackC =
Ptr GValue ->
Ptr GValue ->
IO ()
foreign import ccall "wrapper"
mkTypeValueTableValueCopyFieldCallback :: TypeValueTableValueCopyFieldCallbackC -> IO (FunPtr TypeValueTableValueCopyFieldCallbackC)
type TypeValueTableValueCopyFieldCallback =
GValue ->
GValue ->
IO ()
noTypeValueTableValueCopyFieldCallback :: Maybe TypeValueTableValueCopyFieldCallback
noTypeValueTableValueCopyFieldCallback = Nothing
typeValueTableValueCopyFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (TypeValueTableValueCopyFieldCallbackC))) ->
TypeValueTableValueCopyFieldCallback ->
Ptr GValue ->
Ptr GValue ->
IO ()
typeValueTableValueCopyFieldCallbackWrapper funptrptr _cb src_value dest_value = do
src_value' <- (newBoxed GValue) src_value
dest_value' <- (newBoxed GValue) dest_value
_cb src_value' dest_value'
maybeReleaseFunPtr funptrptr
typeValueTableLcopyValueFieldCallbackClosure :: TypeValueTableLcopyValueFieldCallback -> IO Closure
typeValueTableLcopyValueFieldCallbackClosure cb = newCClosure =<< mkTypeValueTableLcopyValueFieldCallback wrapped
where wrapped = typeValueTableLcopyValueFieldCallbackWrapper Nothing cb
type TypeValueTableLcopyValueFieldCallbackC =
Ptr GValue ->
Word32 ->
Ptr TypeCValue ->
Word32 ->
IO CString
foreign import ccall "wrapper"
mkTypeValueTableLcopyValueFieldCallback :: TypeValueTableLcopyValueFieldCallbackC -> IO (FunPtr TypeValueTableLcopyValueFieldCallbackC)
type TypeValueTableLcopyValueFieldCallback =
GValue ->
Word32 ->
TypeCValue ->
Word32 ->
IO T.Text
noTypeValueTableLcopyValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback
noTypeValueTableLcopyValueFieldCallback = Nothing
typeValueTableLcopyValueFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (TypeValueTableLcopyValueFieldCallbackC))) ->
TypeValueTableLcopyValueFieldCallback ->
Ptr GValue ->
Word32 ->
Ptr TypeCValue ->
Word32 ->
IO CString
typeValueTableLcopyValueFieldCallbackWrapper funptrptr _cb value n_collect_values collect_values collect_flags = do
value' <- (newBoxed GValue) value
collect_values' <- (newPtr 8 TypeCValue) collect_values
result <- _cb value' n_collect_values collect_values' collect_flags
maybeReleaseFunPtr funptrptr
result' <- textToCString result
return result'
typeValueTableCollectValueFieldCallbackClosure :: TypeValueTableCollectValueFieldCallback -> IO Closure
typeValueTableCollectValueFieldCallbackClosure cb = newCClosure =<< mkTypeValueTableCollectValueFieldCallback wrapped
where wrapped = typeValueTableCollectValueFieldCallbackWrapper Nothing cb
type TypeValueTableCollectValueFieldCallbackC =
Ptr GValue ->
Word32 ->
Ptr TypeCValue ->
Word32 ->
IO CString
foreign import ccall "wrapper"
mkTypeValueTableCollectValueFieldCallback :: TypeValueTableCollectValueFieldCallbackC -> IO (FunPtr TypeValueTableCollectValueFieldCallbackC)
type TypeValueTableCollectValueFieldCallback =
GValue ->
Word32 ->
TypeCValue ->
Word32 ->
IO T.Text
noTypeValueTableCollectValueFieldCallback :: Maybe TypeValueTableCollectValueFieldCallback
noTypeValueTableCollectValueFieldCallback = Nothing
typeValueTableCollectValueFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (TypeValueTableCollectValueFieldCallbackC))) ->
TypeValueTableCollectValueFieldCallback ->
Ptr GValue ->
Word32 ->
Ptr TypeCValue ->
Word32 ->
IO CString
typeValueTableCollectValueFieldCallbackWrapper funptrptr _cb value n_collect_values collect_values collect_flags = do
value' <- (newBoxed GValue) value
collect_values' <- (newPtr 8 TypeCValue) collect_values
result <- _cb value' n_collect_values collect_values' collect_flags
maybeReleaseFunPtr funptrptr
result' <- textToCString result
return result'
typeInterfaceCheckFuncClosure :: TypeInterfaceCheckFunc -> IO Closure
typeInterfaceCheckFuncClosure cb = newCClosure =<< mkTypeInterfaceCheckFunc wrapped
where wrapped = typeInterfaceCheckFuncWrapper Nothing cb
type TypeInterfaceCheckFuncC =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkTypeInterfaceCheckFunc :: TypeInterfaceCheckFuncC -> IO (FunPtr TypeInterfaceCheckFuncC)
type TypeInterfaceCheckFunc =
Ptr () ->
Ptr () ->
IO ()
noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc
noTypeInterfaceCheckFunc = Nothing
typeInterfaceCheckFuncWrapper ::
Maybe (Ptr (FunPtr (TypeInterfaceCheckFuncC))) ->
TypeInterfaceCheckFunc ->
Ptr () ->
Ptr () ->
IO ()
typeInterfaceCheckFuncWrapper funptrptr _cb check_data g_iface = do
_cb check_data g_iface
maybeReleaseFunPtr funptrptr
typeClassCacheFuncClosure :: TypeClassCacheFunc -> IO Closure
typeClassCacheFuncClosure cb = newCClosure =<< mkTypeClassCacheFunc wrapped
where wrapped = typeClassCacheFuncWrapper Nothing cb
type TypeClassCacheFuncC =
Ptr () ->
Ptr TypeClass ->
IO CInt
foreign import ccall "wrapper"
mkTypeClassCacheFunc :: TypeClassCacheFuncC -> IO (FunPtr TypeClassCacheFuncC)
type TypeClassCacheFunc =
Ptr () ->
TypeClass ->
IO Bool
noTypeClassCacheFunc :: Maybe TypeClassCacheFunc
noTypeClassCacheFunc = Nothing
typeClassCacheFuncWrapper ::
Maybe (Ptr (FunPtr (TypeClassCacheFuncC))) ->
TypeClassCacheFunc ->
Ptr () ->
Ptr TypeClass ->
IO CInt
typeClassCacheFuncWrapper funptrptr _cb cache_data g_class = do
g_class' <- (newPtr 8 TypeClass) g_class
result <- _cb cache_data g_class'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
toggleNotifyClosure :: ToggleNotify -> IO Closure
toggleNotifyClosure cb = newCClosure =<< mkToggleNotify wrapped
where wrapped = toggleNotifyWrapper Nothing cb
type ToggleNotifyC =
Ptr () ->
Ptr Object ->
CInt ->
IO ()
foreign import ccall "wrapper"
mkToggleNotify :: ToggleNotifyC -> IO (FunPtr ToggleNotifyC)
type ToggleNotify =
Ptr () ->
Object ->
Bool ->
IO ()
noToggleNotify :: Maybe ToggleNotify
noToggleNotify = Nothing
toggleNotifyWrapper ::
Maybe (Ptr (FunPtr (ToggleNotifyC))) ->
ToggleNotify ->
Ptr () ->
Ptr Object ->
CInt ->
IO ()
toggleNotifyWrapper funptrptr _cb data_ object is_last_ref = do
object' <- (newObject Object) object
let is_last_ref' = (/= 0) is_last_ref
_cb data_ object' is_last_ref'
maybeReleaseFunPtr funptrptr
signalEmissionHookClosure :: SignalEmissionHook -> IO Closure
signalEmissionHookClosure cb = newCClosure =<< mkSignalEmissionHook wrapped
where wrapped = signalEmissionHookWrapper Nothing cb
type SignalEmissionHookC =
Ptr SignalInvocationHint ->
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkSignalEmissionHook :: SignalEmissionHookC -> IO (FunPtr SignalEmissionHookC)
type SignalEmissionHook =
SignalInvocationHint ->
[GValue] ->
Ptr () ->
IO Bool
noSignalEmissionHook :: Maybe SignalEmissionHook
noSignalEmissionHook = Nothing
signalEmissionHookWrapper ::
Maybe (Ptr (FunPtr (SignalEmissionHookC))) ->
SignalEmissionHook ->
Ptr SignalInvocationHint ->
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
signalEmissionHookWrapper funptrptr _cb ihint n_param_values param_values data_ = do
ihint' <- (newPtr 12 SignalInvocationHint) ihint
param_values' <- (unpackBoxedArrayWithLength 24 n_param_values) param_values
param_values'' <- mapM (newBoxed GValue) param_values'
result <- _cb ihint' param_values'' data_
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
signalAccumulatorClosure :: SignalAccumulator -> IO Closure
signalAccumulatorClosure cb = newCClosure =<< mkSignalAccumulator wrapped
where wrapped = signalAccumulatorWrapper Nothing cb
type SignalAccumulatorC =
Ptr SignalInvocationHint ->
Ptr GValue ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkSignalAccumulator :: SignalAccumulatorC -> IO (FunPtr SignalAccumulatorC)
type SignalAccumulator =
SignalInvocationHint ->
GValue ->
GValue ->
Ptr () ->
IO Bool
noSignalAccumulator :: Maybe SignalAccumulator
noSignalAccumulator = Nothing
signalAccumulatorWrapper ::
Maybe (Ptr (FunPtr (SignalAccumulatorC))) ->
SignalAccumulator ->
Ptr SignalInvocationHint ->
Ptr GValue ->
Ptr GValue ->
Ptr () ->
IO CInt
signalAccumulatorWrapper funptrptr _cb ihint return_accu handler_return data_ = do
ihint' <- (newPtr 12 SignalInvocationHint) ihint
return_accu' <- (newBoxed GValue) return_accu
handler_return' <- (newBoxed GValue) handler_return
result <- _cb ihint' return_accu' handler_return' data_
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
paramSpecTypeInfoValuesCmpFieldCallbackClosure :: ParamSpecTypeInfoValuesCmpFieldCallback -> IO Closure
paramSpecTypeInfoValuesCmpFieldCallbackClosure cb = newCClosure =<< mkParamSpecTypeInfoValuesCmpFieldCallback wrapped
where wrapped = paramSpecTypeInfoValuesCmpFieldCallbackWrapper Nothing cb
type ParamSpecTypeInfoValuesCmpFieldCallbackC =
Ptr GParamSpec ->
Ptr GValue ->
Ptr GValue ->
IO Int32
foreign import ccall "wrapper"
mkParamSpecTypeInfoValuesCmpFieldCallback :: ParamSpecTypeInfoValuesCmpFieldCallbackC -> IO (FunPtr ParamSpecTypeInfoValuesCmpFieldCallbackC)
type ParamSpecTypeInfoValuesCmpFieldCallback =
GParamSpec ->
GValue ->
GValue ->
IO Int32
noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback
noParamSpecTypeInfoValuesCmpFieldCallback = Nothing
paramSpecTypeInfoValuesCmpFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (ParamSpecTypeInfoValuesCmpFieldCallbackC))) ->
ParamSpecTypeInfoValuesCmpFieldCallback ->
Ptr GParamSpec ->
Ptr GValue ->
Ptr GValue ->
IO Int32
paramSpecTypeInfoValuesCmpFieldCallbackWrapper funptrptr _cb pspec value1 value2 = do
pspec' <- newGParamSpecFromPtr pspec
value1' <- (newBoxed GValue) value1
value2' <- (newBoxed GValue) value2
result <- _cb pspec' value1' value2'
maybeReleaseFunPtr funptrptr
return result
paramSpecTypeInfoValueValidateFieldCallbackClosure :: ParamSpecTypeInfoValueValidateFieldCallback -> IO Closure
paramSpecTypeInfoValueValidateFieldCallbackClosure cb = newCClosure =<< mkParamSpecTypeInfoValueValidateFieldCallback wrapped
where wrapped = paramSpecTypeInfoValueValidateFieldCallbackWrapper Nothing cb
type ParamSpecTypeInfoValueValidateFieldCallbackC =
Ptr GParamSpec ->
Ptr GValue ->
IO CInt
foreign import ccall "wrapper"
mkParamSpecTypeInfoValueValidateFieldCallback :: ParamSpecTypeInfoValueValidateFieldCallbackC -> IO (FunPtr ParamSpecTypeInfoValueValidateFieldCallbackC)
type ParamSpecTypeInfoValueValidateFieldCallback =
GParamSpec ->
GValue ->
IO Bool
noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback
noParamSpecTypeInfoValueValidateFieldCallback = Nothing
paramSpecTypeInfoValueValidateFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (ParamSpecTypeInfoValueValidateFieldCallbackC))) ->
ParamSpecTypeInfoValueValidateFieldCallback ->
Ptr GParamSpec ->
Ptr GValue ->
IO CInt
paramSpecTypeInfoValueValidateFieldCallbackWrapper funptrptr _cb pspec value = do
pspec' <- newGParamSpecFromPtr pspec
value' <- (newBoxed GValue) value
result <- _cb pspec' value'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
paramSpecTypeInfoValueSetDefaultFieldCallbackClosure :: ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO Closure
paramSpecTypeInfoValueSetDefaultFieldCallbackClosure cb = newCClosure =<< mkParamSpecTypeInfoValueSetDefaultFieldCallback wrapped
where wrapped = paramSpecTypeInfoValueSetDefaultFieldCallbackWrapper Nothing cb
type ParamSpecTypeInfoValueSetDefaultFieldCallbackC =
Ptr GParamSpec ->
Ptr GValue ->
IO ()
foreign import ccall "wrapper"
mkParamSpecTypeInfoValueSetDefaultFieldCallback :: ParamSpecTypeInfoValueSetDefaultFieldCallbackC -> IO (FunPtr ParamSpecTypeInfoValueSetDefaultFieldCallbackC)
type ParamSpecTypeInfoValueSetDefaultFieldCallback =
GParamSpec ->
GValue ->
IO ()
noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback
noParamSpecTypeInfoValueSetDefaultFieldCallback = Nothing
paramSpecTypeInfoValueSetDefaultFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (ParamSpecTypeInfoValueSetDefaultFieldCallbackC))) ->
ParamSpecTypeInfoValueSetDefaultFieldCallback ->
Ptr GParamSpec ->
Ptr GValue ->
IO ()
paramSpecTypeInfoValueSetDefaultFieldCallbackWrapper funptrptr _cb pspec value = do
pspec' <- newGParamSpecFromPtr pspec
value' <- (newBoxed GValue) value
_cb pspec' value'
maybeReleaseFunPtr funptrptr
paramSpecTypeInfoInstanceInitFieldCallbackClosure :: ParamSpecTypeInfoInstanceInitFieldCallback -> IO Closure
paramSpecTypeInfoInstanceInitFieldCallbackClosure cb = newCClosure =<< mkParamSpecTypeInfoInstanceInitFieldCallback wrapped
where wrapped = paramSpecTypeInfoInstanceInitFieldCallbackWrapper Nothing cb
type ParamSpecTypeInfoInstanceInitFieldCallbackC =
Ptr GParamSpec ->
IO ()
foreign import ccall "wrapper"
mkParamSpecTypeInfoInstanceInitFieldCallback :: ParamSpecTypeInfoInstanceInitFieldCallbackC -> IO (FunPtr ParamSpecTypeInfoInstanceInitFieldCallbackC)
type ParamSpecTypeInfoInstanceInitFieldCallback =
GParamSpec ->
IO ()
noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback
noParamSpecTypeInfoInstanceInitFieldCallback = Nothing
paramSpecTypeInfoInstanceInitFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (ParamSpecTypeInfoInstanceInitFieldCallbackC))) ->
ParamSpecTypeInfoInstanceInitFieldCallback ->
Ptr GParamSpec ->
IO ()
paramSpecTypeInfoInstanceInitFieldCallbackWrapper funptrptr _cb pspec = do
pspec' <- newGParamSpecFromPtr pspec
_cb pspec'
maybeReleaseFunPtr funptrptr
paramSpecTypeInfoFinalizeFieldCallbackClosure :: ParamSpecTypeInfoFinalizeFieldCallback -> IO Closure
paramSpecTypeInfoFinalizeFieldCallbackClosure cb = newCClosure =<< mkParamSpecTypeInfoFinalizeFieldCallback wrapped
where wrapped = paramSpecTypeInfoFinalizeFieldCallbackWrapper Nothing cb
type ParamSpecTypeInfoFinalizeFieldCallbackC =
Ptr GParamSpec ->
IO ()
foreign import ccall "wrapper"
mkParamSpecTypeInfoFinalizeFieldCallback :: ParamSpecTypeInfoFinalizeFieldCallbackC -> IO (FunPtr ParamSpecTypeInfoFinalizeFieldCallbackC)
type ParamSpecTypeInfoFinalizeFieldCallback =
GParamSpec ->
IO ()
noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback
noParamSpecTypeInfoFinalizeFieldCallback = Nothing
paramSpecTypeInfoFinalizeFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (ParamSpecTypeInfoFinalizeFieldCallbackC))) ->
ParamSpecTypeInfoFinalizeFieldCallback ->
Ptr GParamSpec ->
IO ()
paramSpecTypeInfoFinalizeFieldCallbackWrapper funptrptr _cb pspec = do
pspec' <- newGParamSpecFromPtr pspec
_cb pspec'
maybeReleaseFunPtr funptrptr
objectSetPropertyFuncClosure :: ObjectSetPropertyFunc -> IO Closure
objectSetPropertyFuncClosure cb = newCClosure =<< mkObjectSetPropertyFunc wrapped
where wrapped = objectSetPropertyFuncWrapper Nothing cb
type ObjectSetPropertyFuncC =
Ptr Object ->
Word32 ->
Ptr GValue ->
Ptr GParamSpec ->
IO ()
foreign import ccall "wrapper"
mkObjectSetPropertyFunc :: ObjectSetPropertyFuncC -> IO (FunPtr ObjectSetPropertyFuncC)
type ObjectSetPropertyFunc =
Object ->
Word32 ->
GValue ->
GParamSpec ->
IO ()
noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc
noObjectSetPropertyFunc = Nothing
objectSetPropertyFuncWrapper ::
Maybe (Ptr (FunPtr (ObjectSetPropertyFuncC))) ->
ObjectSetPropertyFunc ->
Ptr Object ->
Word32 ->
Ptr GValue ->
Ptr GParamSpec ->
IO ()
objectSetPropertyFuncWrapper funptrptr _cb object property_id value pspec = do
object' <- (newObject Object) object
value' <- (newBoxed GValue) value
pspec' <- newGParamSpecFromPtr pspec
_cb object' property_id value' pspec'
maybeReleaseFunPtr funptrptr
objectGetPropertyFuncClosure :: ObjectGetPropertyFunc -> IO Closure
objectGetPropertyFuncClosure cb = newCClosure =<< mkObjectGetPropertyFunc wrapped
where wrapped = objectGetPropertyFuncWrapper Nothing cb
type ObjectGetPropertyFuncC =
Ptr Object ->
Word32 ->
Ptr GValue ->
Ptr GParamSpec ->
IO ()
foreign import ccall "wrapper"
mkObjectGetPropertyFunc :: ObjectGetPropertyFuncC -> IO (FunPtr ObjectGetPropertyFuncC)
type ObjectGetPropertyFunc =
Object ->
Word32 ->
GValue ->
GParamSpec ->
IO ()
noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc
noObjectGetPropertyFunc = Nothing
objectGetPropertyFuncWrapper ::
Maybe (Ptr (FunPtr (ObjectGetPropertyFuncC))) ->
ObjectGetPropertyFunc ->
Ptr Object ->
Word32 ->
Ptr GValue ->
Ptr GParamSpec ->
IO ()
objectGetPropertyFuncWrapper funptrptr _cb object property_id value pspec = do
object' <- (newObject Object) object
value' <- (newBoxed GValue) value
pspec' <- newGParamSpecFromPtr pspec
_cb object' property_id value' pspec'
maybeReleaseFunPtr funptrptr
objectFinalizeFuncClosure :: ObjectFinalizeFunc -> IO Closure
objectFinalizeFuncClosure cb = newCClosure =<< mkObjectFinalizeFunc wrapped
where wrapped = objectFinalizeFuncWrapper Nothing cb
type ObjectFinalizeFuncC =
Ptr Object ->
IO ()
foreign import ccall "wrapper"
mkObjectFinalizeFunc :: ObjectFinalizeFuncC -> IO (FunPtr ObjectFinalizeFuncC)
type ObjectFinalizeFunc =
Object ->
IO ()
noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc
noObjectFinalizeFunc = Nothing
objectFinalizeFuncWrapper ::
Maybe (Ptr (FunPtr (ObjectFinalizeFuncC))) ->
ObjectFinalizeFunc ->
Ptr Object ->
IO ()
objectFinalizeFuncWrapper funptrptr _cb object = do
object' <- (newObject Object) object
_cb object'
maybeReleaseFunPtr funptrptr
interfaceInitFuncClosure :: InterfaceInitFunc -> IO Closure
interfaceInitFuncClosure cb = newCClosure =<< mkInterfaceInitFunc wrapped
where wrapped = interfaceInitFuncWrapper Nothing cb
type InterfaceInitFuncC =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkInterfaceInitFunc :: InterfaceInitFuncC -> IO (FunPtr InterfaceInitFuncC)
type InterfaceInitFunc =
Ptr () ->
Ptr () ->
IO ()
noInterfaceInitFunc :: Maybe InterfaceInitFunc
noInterfaceInitFunc = Nothing
interfaceInitFuncWrapper ::
Maybe (Ptr (FunPtr (InterfaceInitFuncC))) ->
InterfaceInitFunc ->
Ptr () ->
Ptr () ->
IO ()
interfaceInitFuncWrapper funptrptr _cb g_iface iface_data = do
_cb g_iface iface_data
maybeReleaseFunPtr funptrptr
interfaceFinalizeFuncClosure :: InterfaceFinalizeFunc -> IO Closure
interfaceFinalizeFuncClosure cb = newCClosure =<< mkInterfaceFinalizeFunc wrapped
where wrapped = interfaceFinalizeFuncWrapper Nothing cb
type InterfaceFinalizeFuncC =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkInterfaceFinalizeFunc :: InterfaceFinalizeFuncC -> IO (FunPtr InterfaceFinalizeFuncC)
type InterfaceFinalizeFunc =
Ptr () ->
Ptr () ->
IO ()
noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc
noInterfaceFinalizeFunc = Nothing
interfaceFinalizeFuncWrapper ::
Maybe (Ptr (FunPtr (InterfaceFinalizeFuncC))) ->
InterfaceFinalizeFunc ->
Ptr () ->
Ptr () ->
IO ()
interfaceFinalizeFuncWrapper funptrptr _cb g_iface iface_data = do
_cb g_iface iface_data
maybeReleaseFunPtr funptrptr
instanceInitFuncClosure :: InstanceInitFunc -> IO Closure
instanceInitFuncClosure cb = newCClosure =<< mkInstanceInitFunc wrapped
where wrapped = instanceInitFuncWrapper Nothing cb
type InstanceInitFuncC =
Ptr TypeInstance ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkInstanceInitFunc :: InstanceInitFuncC -> IO (FunPtr InstanceInitFuncC)
type InstanceInitFunc =
TypeInstance ->
Ptr () ->
IO ()
noInstanceInitFunc :: Maybe InstanceInitFunc
noInstanceInitFunc = Nothing
instanceInitFuncWrapper ::
Maybe (Ptr (FunPtr (InstanceInitFuncC))) ->
InstanceInitFunc ->
Ptr TypeInstance ->
Ptr () ->
IO ()
instanceInitFuncWrapper funptrptr _cb instance_ g_class = do
instance_' <- (newPtr 8 TypeInstance) instance_
_cb instance_' g_class
maybeReleaseFunPtr funptrptr
closureNotifyClosure :: ClosureNotify -> IO Closure
closureNotifyClosure cb = newCClosure =<< mkClosureNotify wrapped
where wrapped = closureNotifyWrapper Nothing cb
type ClosureNotifyC =
Ptr () ->
Ptr Closure ->
IO ()
foreign import ccall "wrapper"
mkClosureNotify :: ClosureNotifyC -> IO (FunPtr ClosureNotifyC)
type ClosureNotify =
Ptr () ->
Closure ->
IO ()
noClosureNotify :: Maybe ClosureNotify
noClosureNotify = Nothing
closureNotifyWrapper ::
Maybe (Ptr (FunPtr (ClosureNotifyC))) ->
ClosureNotify ->
Ptr () ->
Ptr Closure ->
IO ()
closureNotifyWrapper funptrptr _cb data_ closure = do
closure' <- (newBoxed Closure) closure
_cb data_ closure'
maybeReleaseFunPtr funptrptr
closureMarshalFieldCallbackClosure :: ClosureMarshalFieldCallback -> IO Closure
closureMarshalFieldCallbackClosure cb = newCClosure =<< mkClosureMarshalFieldCallback wrapped
where wrapped = closureMarshalFieldCallbackWrapper Nothing cb
type ClosureMarshalFieldCallbackC =
Ptr Closure ->
Ptr GValue ->
Word32 ->
Ptr GValue ->
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkClosureMarshalFieldCallback :: ClosureMarshalFieldCallbackC -> IO (FunPtr ClosureMarshalFieldCallbackC)
type ClosureMarshalFieldCallback =
Closure ->
GValue ->
Word32 ->
GValue ->
Ptr () ->
Ptr () ->
IO ()
noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback
noClosureMarshalFieldCallback = Nothing
closureMarshalFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (ClosureMarshalFieldCallbackC))) ->
ClosureMarshalFieldCallback ->
Ptr Closure ->
Ptr GValue ->
Word32 ->
Ptr GValue ->
Ptr () ->
Ptr () ->
IO ()
closureMarshalFieldCallbackWrapper funptrptr _cb closure return_value n_param_values param_values invocation_hint marshal_data = do
closure' <- (newBoxed Closure) closure
return_value' <- (newBoxed GValue) return_value
param_values' <- (newBoxed GValue) param_values
_cb closure' return_value' n_param_values param_values' invocation_hint marshal_data
maybeReleaseFunPtr funptrptr
classInitFuncClosure :: ClassInitFunc -> IO Closure
classInitFuncClosure cb = newCClosure =<< mkClassInitFunc wrapped
where wrapped = classInitFuncWrapper Nothing cb
type ClassInitFuncC =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkClassInitFunc :: ClassInitFuncC -> IO (FunPtr ClassInitFuncC)
type ClassInitFunc =
Ptr () ->
Ptr () ->
IO ()
noClassInitFunc :: Maybe ClassInitFunc
noClassInitFunc = Nothing
classInitFuncWrapper ::
Maybe (Ptr (FunPtr (ClassInitFuncC))) ->
ClassInitFunc ->
Ptr () ->
Ptr () ->
IO ()
classInitFuncWrapper funptrptr _cb g_class class_data = do
_cb g_class class_data
maybeReleaseFunPtr funptrptr
classFinalizeFuncClosure :: ClassFinalizeFunc -> IO Closure
classFinalizeFuncClosure cb = newCClosure =<< mkClassFinalizeFunc wrapped
where wrapped = classFinalizeFuncWrapper Nothing cb
type ClassFinalizeFuncC =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkClassFinalizeFunc :: ClassFinalizeFuncC -> IO (FunPtr ClassFinalizeFuncC)
type ClassFinalizeFunc =
Ptr () ->
Ptr () ->
IO ()
noClassFinalizeFunc :: Maybe ClassFinalizeFunc
noClassFinalizeFunc = Nothing
classFinalizeFuncWrapper ::
Maybe (Ptr (FunPtr (ClassFinalizeFuncC))) ->
ClassFinalizeFunc ->
Ptr () ->
Ptr () ->
IO ()
classFinalizeFuncWrapper funptrptr _cb g_class class_data = do
_cb g_class class_data
maybeReleaseFunPtr funptrptr
callbackClosure :: Callback -> IO Closure
callbackClosure cb = newCClosure =<< mkCallback wrapped
where wrapped = callbackWrapper Nothing cb
type CallbackC =
IO ()
foreign import ccall "wrapper"
mkCallback :: CallbackC -> IO (FunPtr CallbackC)
type Callback =
IO ()
noCallback :: Maybe Callback
noCallback = Nothing
callbackWrapper ::
Maybe (Ptr (FunPtr (CallbackC))) ->
Callback ->
IO ()
callbackWrapper funptrptr _cb = do
_cb
maybeReleaseFunPtr funptrptr
boxedFreeFuncClosure :: BoxedFreeFunc -> IO Closure
boxedFreeFuncClosure cb = newCClosure =<< mkBoxedFreeFunc wrapped
where wrapped = boxedFreeFuncWrapper Nothing cb
type BoxedFreeFuncC =
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkBoxedFreeFunc :: BoxedFreeFuncC -> IO (FunPtr BoxedFreeFuncC)
type BoxedFreeFunc =
Ptr () ->
IO ()
noBoxedFreeFunc :: Maybe BoxedFreeFunc
noBoxedFreeFunc = Nothing
boxedFreeFuncWrapper ::
Maybe (Ptr (FunPtr (BoxedFreeFuncC))) ->
BoxedFreeFunc ->
Ptr () ->
IO ()
boxedFreeFuncWrapper funptrptr _cb boxed = do
_cb boxed
maybeReleaseFunPtr funptrptr
bindingTransformFuncClosure :: BindingTransformFunc -> IO Closure
bindingTransformFuncClosure cb = newCClosure =<< mkBindingTransformFunc wrapped
where wrapped = bindingTransformFuncWrapper Nothing cb
type BindingTransformFuncC =
Ptr Binding ->
Ptr GValue ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkBindingTransformFunc :: BindingTransformFuncC -> IO (FunPtr BindingTransformFuncC)
type BindingTransformFunc =
Binding ->
GValue ->
GValue ->
IO Bool
noBindingTransformFunc :: Maybe BindingTransformFunc
noBindingTransformFunc = Nothing
bindingTransformFuncWrapper ::
Maybe (Ptr (FunPtr (BindingTransformFuncC))) ->
BindingTransformFunc ->
Ptr Binding ->
Ptr GValue ->
Ptr GValue ->
Ptr () ->
IO CInt
bindingTransformFuncWrapper funptrptr _cb binding from_value to_value _ = do
binding' <- (newObject Binding) binding
from_value' <- (newBoxed GValue) from_value
to_value' <- (newBoxed GValue) to_value
result <- _cb binding' from_value' to_value'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
baseInitFuncClosure :: BaseInitFunc -> IO Closure
baseInitFuncClosure cb = newCClosure =<< mkBaseInitFunc wrapped
where wrapped = baseInitFuncWrapper Nothing cb
type BaseInitFuncC =
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkBaseInitFunc :: BaseInitFuncC -> IO (FunPtr BaseInitFuncC)
type BaseInitFunc =
Ptr () ->
IO ()
noBaseInitFunc :: Maybe BaseInitFunc
noBaseInitFunc = Nothing
baseInitFuncWrapper ::
Maybe (Ptr (FunPtr (BaseInitFuncC))) ->
BaseInitFunc ->
Ptr () ->
IO ()
baseInitFuncWrapper funptrptr _cb g_class = do
_cb g_class
maybeReleaseFunPtr funptrptr
baseFinalizeFuncClosure :: BaseFinalizeFunc -> IO Closure
baseFinalizeFuncClosure cb = newCClosure =<< mkBaseFinalizeFunc wrapped
where wrapped = baseFinalizeFuncWrapper Nothing cb
type BaseFinalizeFuncC =
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkBaseFinalizeFunc :: BaseFinalizeFuncC -> IO (FunPtr BaseFinalizeFuncC)
type BaseFinalizeFunc =
Ptr () ->
IO ()
noBaseFinalizeFunc :: Maybe BaseFinalizeFunc
noBaseFinalizeFunc = Nothing
baseFinalizeFuncWrapper ::
Maybe (Ptr (FunPtr (BaseFinalizeFuncC))) ->
BaseFinalizeFunc ->
Ptr () ->
IO ()
baseFinalizeFuncWrapper funptrptr _cb g_class = do
_cb g_class
maybeReleaseFunPtr funptrptr