{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.GObject.Callbacks
    (

 -- * Signals
-- ** BaseFinalizeFunc #signal:BaseFinalizeFunc#

    BaseFinalizeFunc                        ,
    C_BaseFinalizeFunc                      ,
    dynamic_BaseFinalizeFunc                ,
    genClosure_BaseFinalizeFunc             ,
    mk_BaseFinalizeFunc                     ,
    noBaseFinalizeFunc                      ,
    wrap_BaseFinalizeFunc                   ,


-- ** BaseInitFunc #signal:BaseInitFunc#

    BaseInitFunc                            ,
    C_BaseInitFunc                          ,
    dynamic_BaseInitFunc                    ,
    genClosure_BaseInitFunc                 ,
    mk_BaseInitFunc                         ,
    noBaseInitFunc                          ,
    wrap_BaseInitFunc                       ,


-- ** BindingTransformFunc #signal:BindingTransformFunc#

    BindingTransformFunc                    ,
    BindingTransformFunc_WithClosures       ,
    C_BindingTransformFunc                  ,
    drop_closures_BindingTransformFunc      ,
    dynamic_BindingTransformFunc            ,
    genClosure_BindingTransformFunc         ,
    mk_BindingTransformFunc                 ,
    noBindingTransformFunc                  ,
    noBindingTransformFunc_WithClosures     ,
    wrap_BindingTransformFunc               ,


-- ** BoxedCopyFunc #signal:BoxedCopyFunc#

    BoxedCopyFunc                           ,
    C_BoxedCopyFunc                         ,
    dynamic_BoxedCopyFunc                   ,
    genClosure_BoxedCopyFunc                ,
    mk_BoxedCopyFunc                        ,
    noBoxedCopyFunc                         ,
    wrap_BoxedCopyFunc                      ,


-- ** BoxedFreeFunc #signal:BoxedFreeFunc#

    BoxedFreeFunc                           ,
    C_BoxedFreeFunc                         ,
    dynamic_BoxedFreeFunc                   ,
    genClosure_BoxedFreeFunc                ,
    mk_BoxedFreeFunc                        ,
    noBoxedFreeFunc                         ,
    wrap_BoxedFreeFunc                      ,


-- ** Callback #signal:Callback#

    C_Callback                              ,
    Callback                                ,
    dynamic_Callback                        ,
    genClosure_Callback                     ,
    mk_Callback                             ,
    noCallback                              ,
    wrap_Callback                           ,


-- ** ClassFinalizeFunc #signal:ClassFinalizeFunc#

    C_ClassFinalizeFunc                     ,
    ClassFinalizeFunc                       ,
    dynamic_ClassFinalizeFunc               ,
    genClosure_ClassFinalizeFunc            ,
    mk_ClassFinalizeFunc                    ,
    noClassFinalizeFunc                     ,
    wrap_ClassFinalizeFunc                  ,


-- ** ClassInitFunc #signal:ClassInitFunc#

    C_ClassInitFunc                         ,
    ClassInitFunc                           ,
    dynamic_ClassInitFunc                   ,
    genClosure_ClassInitFunc                ,
    mk_ClassInitFunc                        ,
    noClassInitFunc                         ,
    wrap_ClassInitFunc                      ,


-- ** ClosureMarshalFieldCallback #signal:ClosureMarshalFieldCallback#

    C_ClosureMarshalFieldCallback           ,
    ClosureMarshalFieldCallback             ,
    dynamic_ClosureMarshalFieldCallback     ,
    genClosure_ClosureMarshalFieldCallback  ,
    mk_ClosureMarshalFieldCallback          ,
    noClosureMarshalFieldCallback           ,
    wrap_ClosureMarshalFieldCallback        ,


-- ** ClosureNotify #signal:ClosureNotify#

    C_ClosureNotify                         ,
    ClosureNotify                           ,
    dynamic_ClosureNotify                   ,
    genClosure_ClosureNotify                ,
    mk_ClosureNotify                        ,
    noClosureNotify                         ,
    wrap_ClosureNotify                      ,


-- ** InstanceInitFunc #signal:InstanceInitFunc#

    C_InstanceInitFunc                      ,
    InstanceInitFunc                        ,
    dynamic_InstanceInitFunc                ,
    genClosure_InstanceInitFunc             ,
    mk_InstanceInitFunc                     ,
    noInstanceInitFunc                      ,
    wrap_InstanceInitFunc                   ,


-- ** InterfaceFinalizeFunc #signal:InterfaceFinalizeFunc#

    C_InterfaceFinalizeFunc                 ,
    InterfaceFinalizeFunc                   ,
    dynamic_InterfaceFinalizeFunc           ,
    genClosure_InterfaceFinalizeFunc        ,
    mk_InterfaceFinalizeFunc                ,
    noInterfaceFinalizeFunc                 ,
    wrap_InterfaceFinalizeFunc              ,


-- ** InterfaceInitFunc #signal:InterfaceInitFunc#

    C_InterfaceInitFunc                     ,
    InterfaceInitFunc                       ,
    dynamic_InterfaceInitFunc               ,
    genClosure_InterfaceInitFunc            ,
    mk_InterfaceInitFunc                    ,
    noInterfaceInitFunc                     ,
    wrap_InterfaceInitFunc                  ,


-- ** ObjectFinalizeFunc #signal:ObjectFinalizeFunc#

    C_ObjectFinalizeFunc                    ,
    ObjectFinalizeFunc                      ,
    dynamic_ObjectFinalizeFunc              ,
    genClosure_ObjectFinalizeFunc           ,
    mk_ObjectFinalizeFunc                   ,
    noObjectFinalizeFunc                    ,
    wrap_ObjectFinalizeFunc                 ,


-- ** ObjectGetPropertyFunc #signal:ObjectGetPropertyFunc#

    C_ObjectGetPropertyFunc                 ,
    ObjectGetPropertyFunc                   ,
    dynamic_ObjectGetPropertyFunc           ,
    genClosure_ObjectGetPropertyFunc        ,
    mk_ObjectGetPropertyFunc                ,
    noObjectGetPropertyFunc                 ,
    wrap_ObjectGetPropertyFunc              ,


-- ** ObjectSetPropertyFunc #signal:ObjectSetPropertyFunc#

    C_ObjectSetPropertyFunc                 ,
    ObjectSetPropertyFunc                   ,
    dynamic_ObjectSetPropertyFunc           ,
    genClosure_ObjectSetPropertyFunc        ,
    mk_ObjectSetPropertyFunc                ,
    noObjectSetPropertyFunc                 ,
    wrap_ObjectSetPropertyFunc              ,


-- ** ParamSpecTypeInfoFinalizeFieldCallback #signal:ParamSpecTypeInfoFinalizeFieldCallback#

    C_ParamSpecTypeInfoFinalizeFieldCallback,
    ParamSpecTypeInfoFinalizeFieldCallback  ,
    dynamic_ParamSpecTypeInfoFinalizeFieldCallback,
    genClosure_ParamSpecTypeInfoFinalizeFieldCallback,
    mk_ParamSpecTypeInfoFinalizeFieldCallback,
    noParamSpecTypeInfoFinalizeFieldCallback,
    wrap_ParamSpecTypeInfoFinalizeFieldCallback,


-- ** ParamSpecTypeInfoInstanceInitFieldCallback #signal:ParamSpecTypeInfoInstanceInitFieldCallback#

    C_ParamSpecTypeInfoInstanceInitFieldCallback,
    ParamSpecTypeInfoInstanceInitFieldCallback,
    dynamic_ParamSpecTypeInfoInstanceInitFieldCallback,
    genClosure_ParamSpecTypeInfoInstanceInitFieldCallback,
    mk_ParamSpecTypeInfoInstanceInitFieldCallback,
    noParamSpecTypeInfoInstanceInitFieldCallback,
    wrap_ParamSpecTypeInfoInstanceInitFieldCallback,


-- ** ParamSpecTypeInfoValueSetDefaultFieldCallback #signal:ParamSpecTypeInfoValueSetDefaultFieldCallback#

    C_ParamSpecTypeInfoValueSetDefaultFieldCallback,
    ParamSpecTypeInfoValueSetDefaultFieldCallback,
    dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback,
    genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback,
    mk_ParamSpecTypeInfoValueSetDefaultFieldCallback,
    noParamSpecTypeInfoValueSetDefaultFieldCallback,
    wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback,


-- ** ParamSpecTypeInfoValueValidateFieldCallback #signal:ParamSpecTypeInfoValueValidateFieldCallback#

    C_ParamSpecTypeInfoValueValidateFieldCallback,
    ParamSpecTypeInfoValueValidateFieldCallback,
    dynamic_ParamSpecTypeInfoValueValidateFieldCallback,
    genClosure_ParamSpecTypeInfoValueValidateFieldCallback,
    mk_ParamSpecTypeInfoValueValidateFieldCallback,
    noParamSpecTypeInfoValueValidateFieldCallback,
    wrap_ParamSpecTypeInfoValueValidateFieldCallback,


-- ** ParamSpecTypeInfoValuesCmpFieldCallback #signal:ParamSpecTypeInfoValuesCmpFieldCallback#

    C_ParamSpecTypeInfoValuesCmpFieldCallback,
    ParamSpecTypeInfoValuesCmpFieldCallback ,
    dynamic_ParamSpecTypeInfoValuesCmpFieldCallback,
    genClosure_ParamSpecTypeInfoValuesCmpFieldCallback,
    mk_ParamSpecTypeInfoValuesCmpFieldCallback,
    noParamSpecTypeInfoValuesCmpFieldCallback,
    wrap_ParamSpecTypeInfoValuesCmpFieldCallback,


-- ** SignalAccumulator #signal:SignalAccumulator#

    C_SignalAccumulator                     ,
    SignalAccumulator                       ,
    dynamic_SignalAccumulator               ,
    genClosure_SignalAccumulator            ,
    mk_SignalAccumulator                    ,
    noSignalAccumulator                     ,
    wrap_SignalAccumulator                  ,


-- ** SignalEmissionHook #signal:SignalEmissionHook#

    C_SignalEmissionHook                    ,
    SignalEmissionHook                      ,
    dynamic_SignalEmissionHook              ,
    genClosure_SignalEmissionHook           ,
    mk_SignalEmissionHook                   ,
    noSignalEmissionHook                    ,
    wrap_SignalEmissionHook                 ,


-- ** ToggleNotify #signal:ToggleNotify#

    C_ToggleNotify                          ,
    ToggleNotify                            ,
    dynamic_ToggleNotify                    ,
    genClosure_ToggleNotify                 ,
    mk_ToggleNotify                         ,
    noToggleNotify                          ,
    wrap_ToggleNotify                       ,


-- ** TypeClassCacheFunc #signal:TypeClassCacheFunc#

    C_TypeClassCacheFunc                    ,
    TypeClassCacheFunc                      ,
    dynamic_TypeClassCacheFunc              ,
    genClosure_TypeClassCacheFunc           ,
    mk_TypeClassCacheFunc                   ,
    noTypeClassCacheFunc                    ,
    wrap_TypeClassCacheFunc                 ,


-- ** TypeInterfaceCheckFunc #signal:TypeInterfaceCheckFunc#

    C_TypeInterfaceCheckFunc                ,
    TypeInterfaceCheckFunc                  ,
    dynamic_TypeInterfaceCheckFunc          ,
    genClosure_TypeInterfaceCheckFunc       ,
    mk_TypeInterfaceCheckFunc               ,
    noTypeInterfaceCheckFunc                ,
    wrap_TypeInterfaceCheckFunc             ,


-- ** TypePluginCompleteInterfaceInfo #signal:TypePluginCompleteInterfaceInfo#

    C_TypePluginCompleteInterfaceInfo       ,
    TypePluginCompleteInterfaceInfo         ,
    dynamic_TypePluginCompleteInterfaceInfo ,
    genClosure_TypePluginCompleteInterfaceInfo,
    mk_TypePluginCompleteInterfaceInfo      ,
    noTypePluginCompleteInterfaceInfo       ,
    wrap_TypePluginCompleteInterfaceInfo    ,


-- ** TypePluginCompleteTypeInfo #signal:TypePluginCompleteTypeInfo#

    C_TypePluginCompleteTypeInfo            ,
    TypePluginCompleteTypeInfo              ,
    dynamic_TypePluginCompleteTypeInfo      ,
    genClosure_TypePluginCompleteTypeInfo   ,
    mk_TypePluginCompleteTypeInfo           ,
    noTypePluginCompleteTypeInfo            ,
    wrap_TypePluginCompleteTypeInfo         ,


-- ** TypePluginUnuse #signal:TypePluginUnuse#

    C_TypePluginUnuse                       ,
    TypePluginUnuse                         ,
    dynamic_TypePluginUnuse                 ,
    genClosure_TypePluginUnuse              ,
    mk_TypePluginUnuse                      ,
    noTypePluginUnuse                       ,
    wrap_TypePluginUnuse                    ,


-- ** TypePluginUse #signal:TypePluginUse#

    C_TypePluginUse                         ,
    TypePluginUse                           ,
    dynamic_TypePluginUse                   ,
    genClosure_TypePluginUse                ,
    mk_TypePluginUse                        ,
    noTypePluginUse                         ,
    wrap_TypePluginUse                      ,


-- ** TypeValueTableCollectValueFieldCallback #signal:TypeValueTableCollectValueFieldCallback#

    C_TypeValueTableCollectValueFieldCallback,
    TypeValueTableCollectValueFieldCallback ,
    dynamic_TypeValueTableCollectValueFieldCallback,
    genClosure_TypeValueTableCollectValueFieldCallback,
    mk_TypeValueTableCollectValueFieldCallback,
    noTypeValueTableCollectValueFieldCallback,
    wrap_TypeValueTableCollectValueFieldCallback,


-- ** TypeValueTableLcopyValueFieldCallback #signal:TypeValueTableLcopyValueFieldCallback#

    C_TypeValueTableLcopyValueFieldCallback ,
    TypeValueTableLcopyValueFieldCallback   ,
    dynamic_TypeValueTableLcopyValueFieldCallback,
    genClosure_TypeValueTableLcopyValueFieldCallback,
    mk_TypeValueTableLcopyValueFieldCallback,
    noTypeValueTableLcopyValueFieldCallback ,
    wrap_TypeValueTableLcopyValueFieldCallback,


-- ** TypeValueTableValueCopyFieldCallback #signal:TypeValueTableValueCopyFieldCallback#

    C_TypeValueTableValueCopyFieldCallback  ,
    TypeValueTableValueCopyFieldCallback    ,
    dynamic_TypeValueTableValueCopyFieldCallback,
    genClosure_TypeValueTableValueCopyFieldCallback,
    mk_TypeValueTableValueCopyFieldCallback ,
    noTypeValueTableValueCopyFieldCallback  ,
    wrap_TypeValueTableValueCopyFieldCallback,


-- ** TypeValueTableValueFreeFieldCallback #signal:TypeValueTableValueFreeFieldCallback#

    C_TypeValueTableValueFreeFieldCallback  ,
    TypeValueTableValueFreeFieldCallback    ,
    dynamic_TypeValueTableValueFreeFieldCallback,
    genClosure_TypeValueTableValueFreeFieldCallback,
    mk_TypeValueTableValueFreeFieldCallback ,
    noTypeValueTableValueFreeFieldCallback  ,
    wrap_TypeValueTableValueFreeFieldCallback,


-- ** TypeValueTableValueInitFieldCallback #signal:TypeValueTableValueInitFieldCallback#

    C_TypeValueTableValueInitFieldCallback  ,
    TypeValueTableValueInitFieldCallback    ,
    dynamic_TypeValueTableValueInitFieldCallback,
    genClosure_TypeValueTableValueInitFieldCallback,
    mk_TypeValueTableValueInitFieldCallback ,
    noTypeValueTableValueInitFieldCallback  ,
    wrap_TypeValueTableValueInitFieldCallback,


-- ** TypeValueTableValuePeekPointerFieldCallback #signal:TypeValueTableValuePeekPointerFieldCallback#

    C_TypeValueTableValuePeekPointerFieldCallback,
    TypeValueTableValuePeekPointerFieldCallback,
    dynamic_TypeValueTableValuePeekPointerFieldCallback,
    genClosure_TypeValueTableValuePeekPointerFieldCallback,
    mk_TypeValueTableValuePeekPointerFieldCallback,
    noTypeValueTableValuePeekPointerFieldCallback,
    wrap_TypeValueTableValuePeekPointerFieldCallback,


-- ** ValueTransform #signal:ValueTransform#

    C_ValueTransform                        ,
    ValueTransform                          ,
    dynamic_ValueTransform                  ,
    genClosure_ValueTransform               ,
    mk_ValueTransform                       ,
    noValueTransform                        ,
    wrap_ValueTransform                     ,


-- ** WeakNotify #signal:WeakNotify#

    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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# 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

-- callback WeakNotify
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data that was provided when the weak reference was established", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "where_the_object_was", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object being finalized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A #GWeakNotify function can be added to an object as a callback that gets\ntriggered when the object is finalized. Since the object is already being\nfinalized when the #GWeakNotify is called, there's not much you could do\nwith the object, apart from e.g. using its address as hash-index or the like.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_WeakNotify =
    Ptr () ->
    Ptr GObject.Object.Object ->
    IO ()

-- Args : [Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data that was provided when the weak reference was established", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "where_the_object_was", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object being finalized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_WeakNotify :: FunPtr C_WeakNotify -> C_WeakNotify

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_WeakNotify ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
    FunPtr C_WeakNotify
    -> Ptr ()
    {- ^ /@data@/: data that was provided when the weak reference was established -}
    -> a
    {- ^ /@whereTheObjectWas@/: the object being finalized -}
    -> m ()
dynamic_WeakNotify __funPtr data_ whereTheObjectWas = liftIO $ do
    whereTheObjectWas' <- unsafeManagedPtrCastPtr whereTheObjectWas
    (__dynamic_C_WeakNotify __funPtr) data_ whereTheObjectWas'
    touchManagedPtr whereTheObjectWas
    return ()

-- | Generate a function pointer callable from C code, from a `C_WeakNotify`.
foreign import ccall "wrapper"
    mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify)

{- |
A 'GI.GObject.Callbacks.WeakNotify' function can be added to an object as a callback that gets
triggered when the object is finalized. Since the object is already being
finalized when the 'GI.GObject.Callbacks.WeakNotify' is called, there\'s not much you could do
with the object, apart from e.g. using its address as hash-index or the like.
-}
type WeakNotify =
    Ptr ()
    {- ^ /@data@/: data that was provided when the weak reference was established -}
    -> GObject.Object.Object
    {- ^ /@whereTheObjectWas@/: the object being finalized -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WeakNotify`@.
noWeakNotify :: Maybe WeakNotify
noWeakNotify = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_WeakNotify :: MonadIO m => WeakNotify -> m (GClosure C_WeakNotify)
genClosure_WeakNotify cb = liftIO $ do
    let cb' = wrap_WeakNotify Nothing cb
    mk_WeakNotify cb' >>= B.GClosure.newGClosure


-- | Wrap a `WeakNotify` into a `C_WeakNotify`.
wrap_WeakNotify ::
    Maybe (Ptr (FunPtr C_WeakNotify)) ->
    WeakNotify ->
    C_WeakNotify
wrap_WeakNotify funptrptr _cb data_ whereTheObjectWas = do
    whereTheObjectWas' <- (newObject GObject.Object.Object) whereTheObjectWas
    _cb  data_ whereTheObjectWas'
    maybeReleaseFunPtr funptrptr


-- callback ValueTransform
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "src_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Target value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of value transformation functions which can be registered with\ng_value_register_transform_func().\n\n@dest_value will be initialized to the correct destination type.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ValueTransform =
    Ptr GValue ->
    Ptr GValue ->
    IO ()

-- Args : [Arg {argCName = "src_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Target value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ValueTransform :: FunPtr C_ValueTransform -> C_ValueTransform

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ValueTransform ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ValueTransform
    -> GValue
    {- ^ /@srcValue@/: Source value. -}
    -> GValue
    {- ^ /@destValue@/: Target value. -}
    -> m ()
dynamic_ValueTransform __funPtr srcValue destValue = liftIO $ do
    srcValue' <- unsafeManagedPtrGetPtr srcValue
    destValue' <- unsafeManagedPtrGetPtr destValue
    (__dynamic_C_ValueTransform __funPtr) srcValue' destValue'
    touchManagedPtr srcValue
    touchManagedPtr destValue
    return ()

-- | Generate a function pointer callable from C code, from a `C_ValueTransform`.
foreign import ccall "wrapper"
    mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform)

{- |
The type of value transformation functions which can be registered with
@/g_value_register_transform_func()/@.

/@destValue@/ will be initialized to the correct destination type.
-}
type ValueTransform =
    GValue
    {- ^ /@srcValue@/: Source value. -}
    -> GValue
    {- ^ /@destValue@/: Target value. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ValueTransform`@.
noValueTransform :: Maybe ValueTransform
noValueTransform = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ValueTransform :: MonadIO m => ValueTransform -> m (GClosure C_ValueTransform)
genClosure_ValueTransform cb = liftIO $ do
    let cb' = wrap_ValueTransform Nothing cb
    mk_ValueTransform cb' >>= B.GClosure.newGClosure


-- | Wrap a `ValueTransform` into a `C_ValueTransform`.
wrap_ValueTransform ::
    Maybe (Ptr (FunPtr C_ValueTransform)) ->
    ValueTransform ->
    C_ValueTransform
wrap_ValueTransform funptrptr _cb srcValue destValue = do
    B.ManagedPtr.withTransient GValue srcValue $ \srcValue' -> do
        B.ManagedPtr.withTransient GValue destValue $ \destValue' -> do
            _cb  srcValue' destValue'
            maybeReleaseFunPtr funptrptr


-- callback TypeValueTableValuePeekPointerFieldCallback
--          -> Callable {returnType = Just (TBasicType TPtr), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableValuePeekPointerFieldCallback =
    Ptr GValue ->
    IO (Ptr ())

-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypeValueTableValuePeekPointerFieldCallback :: FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> C_TypeValueTableValuePeekPointerFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypeValueTableValuePeekPointerFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_TypeValueTableValuePeekPointerFieldCallback
    -> GValue
    -> m (Ptr ())
dynamic_TypeValueTableValuePeekPointerFieldCallback __funPtr value = liftIO $ do
    value' <- unsafeManagedPtrGetPtr value
    result <- (__dynamic_C_TypeValueTableValuePeekPointerFieldCallback __funPtr) value'
    touchManagedPtr value
    return result

-- | Generate a function pointer callable from C code, from a `C_TypeValueTableValuePeekPointerFieldCallback`.
foreign import ccall "wrapper"
    mk_TypeValueTableValuePeekPointerFieldCallback :: C_TypeValueTableValuePeekPointerFieldCallback -> IO (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)

{- |
/No description available in the introspection data./
-}
type TypeValueTableValuePeekPointerFieldCallback =
    GValue
    -> IO (Ptr ())

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypeValueTableValuePeekPointerFieldCallback`@.
noTypeValueTableValuePeekPointerFieldCallback :: Maybe TypeValueTableValuePeekPointerFieldCallback
noTypeValueTableValuePeekPointerFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypeValueTableValuePeekPointerFieldCallback :: MonadIO m => TypeValueTableValuePeekPointerFieldCallback -> m (GClosure C_TypeValueTableValuePeekPointerFieldCallback)
genClosure_TypeValueTableValuePeekPointerFieldCallback cb = liftIO $ do
    let cb' = wrap_TypeValueTableValuePeekPointerFieldCallback Nothing cb
    mk_TypeValueTableValuePeekPointerFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypeValueTableValuePeekPointerFieldCallback` into a `C_TypeValueTableValuePeekPointerFieldCallback`.
wrap_TypeValueTableValuePeekPointerFieldCallback ::
    Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)) ->
    TypeValueTableValuePeekPointerFieldCallback ->
    C_TypeValueTableValuePeekPointerFieldCallback
wrap_TypeValueTableValuePeekPointerFieldCallback funptrptr _cb value = do
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        result <- _cb  value'
        maybeReleaseFunPtr funptrptr
        return result


-- callback TypeValueTableValueInitFieldCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableValueInitFieldCallback =
    Ptr GValue ->
    IO ()

-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypeValueTableValueInitFieldCallback :: FunPtr C_TypeValueTableValueInitFieldCallback -> C_TypeValueTableValueInitFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypeValueTableValueInitFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_TypeValueTableValueInitFieldCallback
    -> GValue
    -> m ()
dynamic_TypeValueTableValueInitFieldCallback __funPtr value = liftIO $ do
    value' <- unsafeManagedPtrGetPtr value
    (__dynamic_C_TypeValueTableValueInitFieldCallback __funPtr) value'
    touchManagedPtr value
    return ()

-- | Generate a function pointer callable from C code, from a `C_TypeValueTableValueInitFieldCallback`.
foreign import ccall "wrapper"
    mk_TypeValueTableValueInitFieldCallback :: C_TypeValueTableValueInitFieldCallback -> IO (FunPtr C_TypeValueTableValueInitFieldCallback)

{- |
/No description available in the introspection data./
-}
type TypeValueTableValueInitFieldCallback =
    GValue
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypeValueTableValueInitFieldCallback`@.
noTypeValueTableValueInitFieldCallback :: Maybe TypeValueTableValueInitFieldCallback
noTypeValueTableValueInitFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypeValueTableValueInitFieldCallback :: MonadIO m => TypeValueTableValueInitFieldCallback -> m (GClosure C_TypeValueTableValueInitFieldCallback)
genClosure_TypeValueTableValueInitFieldCallback cb = liftIO $ do
    let cb' = wrap_TypeValueTableValueInitFieldCallback Nothing cb
    mk_TypeValueTableValueInitFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypeValueTableValueInitFieldCallback` into a `C_TypeValueTableValueInitFieldCallback`.
wrap_TypeValueTableValueInitFieldCallback ::
    Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback)) ->
    TypeValueTableValueInitFieldCallback ->
    C_TypeValueTableValueInitFieldCallback
wrap_TypeValueTableValueInitFieldCallback funptrptr _cb value = do
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        _cb  value'
        maybeReleaseFunPtr funptrptr


-- callback TypeValueTableValueFreeFieldCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableValueFreeFieldCallback =
    Ptr GValue ->
    IO ()

-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypeValueTableValueFreeFieldCallback :: FunPtr C_TypeValueTableValueFreeFieldCallback -> C_TypeValueTableValueFreeFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypeValueTableValueFreeFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_TypeValueTableValueFreeFieldCallback
    -> GValue
    -> m ()
dynamic_TypeValueTableValueFreeFieldCallback __funPtr value = liftIO $ do
    value' <- unsafeManagedPtrGetPtr value
    (__dynamic_C_TypeValueTableValueFreeFieldCallback __funPtr) value'
    touchManagedPtr value
    return ()

-- | Generate a function pointer callable from C code, from a `C_TypeValueTableValueFreeFieldCallback`.
foreign import ccall "wrapper"
    mk_TypeValueTableValueFreeFieldCallback :: C_TypeValueTableValueFreeFieldCallback -> IO (FunPtr C_TypeValueTableValueFreeFieldCallback)

{- |
/No description available in the introspection data./
-}
type TypeValueTableValueFreeFieldCallback =
    GValue
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypeValueTableValueFreeFieldCallback`@.
noTypeValueTableValueFreeFieldCallback :: Maybe TypeValueTableValueFreeFieldCallback
noTypeValueTableValueFreeFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypeValueTableValueFreeFieldCallback :: MonadIO m => TypeValueTableValueFreeFieldCallback -> m (GClosure C_TypeValueTableValueFreeFieldCallback)
genClosure_TypeValueTableValueFreeFieldCallback cb = liftIO $ do
    let cb' = wrap_TypeValueTableValueFreeFieldCallback Nothing cb
    mk_TypeValueTableValueFreeFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypeValueTableValueFreeFieldCallback` into a `C_TypeValueTableValueFreeFieldCallback`.
wrap_TypeValueTableValueFreeFieldCallback ::
    Maybe (Ptr (FunPtr C_TypeValueTableValueFreeFieldCallback)) ->
    TypeValueTableValueFreeFieldCallback ->
    C_TypeValueTableValueFreeFieldCallback
wrap_TypeValueTableValueFreeFieldCallback funptrptr _cb value = do
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        _cb  value'
        maybeReleaseFunPtr funptrptr


-- callback TypeValueTableValueCopyFieldCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "src_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableValueCopyFieldCallback =
    Ptr GValue ->
    Ptr GValue ->
    IO ()

-- Args : [Arg {argCName = "src_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypeValueTableValueCopyFieldCallback :: FunPtr C_TypeValueTableValueCopyFieldCallback -> C_TypeValueTableValueCopyFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypeValueTableValueCopyFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_TypeValueTableValueCopyFieldCallback
    -> GValue
    -> GValue
    -> m ()
dynamic_TypeValueTableValueCopyFieldCallback __funPtr srcValue destValue = liftIO $ do
    srcValue' <- unsafeManagedPtrGetPtr srcValue
    destValue' <- unsafeManagedPtrGetPtr destValue
    (__dynamic_C_TypeValueTableValueCopyFieldCallback __funPtr) srcValue' destValue'
    touchManagedPtr srcValue
    touchManagedPtr destValue
    return ()

-- | Generate a function pointer callable from C code, from a `C_TypeValueTableValueCopyFieldCallback`.
foreign import ccall "wrapper"
    mk_TypeValueTableValueCopyFieldCallback :: C_TypeValueTableValueCopyFieldCallback -> IO (FunPtr C_TypeValueTableValueCopyFieldCallback)

{- |
/No description available in the introspection data./
-}
type TypeValueTableValueCopyFieldCallback =
    GValue
    -> GValue
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypeValueTableValueCopyFieldCallback`@.
noTypeValueTableValueCopyFieldCallback :: Maybe TypeValueTableValueCopyFieldCallback
noTypeValueTableValueCopyFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypeValueTableValueCopyFieldCallback :: MonadIO m => TypeValueTableValueCopyFieldCallback -> m (GClosure C_TypeValueTableValueCopyFieldCallback)
genClosure_TypeValueTableValueCopyFieldCallback cb = liftIO $ do
    let cb' = wrap_TypeValueTableValueCopyFieldCallback Nothing cb
    mk_TypeValueTableValueCopyFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypeValueTableValueCopyFieldCallback` into a `C_TypeValueTableValueCopyFieldCallback`.
wrap_TypeValueTableValueCopyFieldCallback ::
    Maybe (Ptr (FunPtr C_TypeValueTableValueCopyFieldCallback)) ->
    TypeValueTableValueCopyFieldCallback ->
    C_TypeValueTableValueCopyFieldCallback
wrap_TypeValueTableValueCopyFieldCallback funptrptr _cb srcValue destValue = do
    B.ManagedPtr.withTransient GValue srcValue $ \srcValue' -> do
        B.ManagedPtr.withTransient GValue destValue $ \destValue' -> do
            _cb  srcValue' destValue'
            maybeReleaseFunPtr funptrptr


-- callback TypeValueTableLcopyValueFieldCallback
--          -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = False, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_collect_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collect_values", argType = TInterface (Name {namespace = "GObject", name = "TypeCValue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collect_flags", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableLcopyValueFieldCallback =
    Ptr GValue ->
    Word32 ->
    Ptr GObject.TypeCValue.TypeCValue ->
    Word32 ->
    IO CString

-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_collect_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collect_values", argType = TInterface (Name {namespace = "GObject", name = "TypeCValue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collect_flags", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypeValueTableLcopyValueFieldCallback :: FunPtr C_TypeValueTableLcopyValueFieldCallback -> C_TypeValueTableLcopyValueFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypeValueTableLcopyValueFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_TypeValueTableLcopyValueFieldCallback
    -> GValue
    -> Word32
    -> GObject.TypeCValue.TypeCValue
    -> Word32
    -> m T.Text
dynamic_TypeValueTableLcopyValueFieldCallback __funPtr value nCollectValues collectValues collectFlags = liftIO $ do
    value' <- unsafeManagedPtrGetPtr value
    collectValues' <- unsafeManagedPtrGetPtr collectValues
    result <- (__dynamic_C_TypeValueTableLcopyValueFieldCallback __funPtr) value' nCollectValues collectValues' collectFlags
    checkUnexpectedReturnNULL "typeValueTableLcopyValueFieldCallback" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr value
    touchManagedPtr collectValues
    return result'

-- | Generate a function pointer callable from C code, from a `C_TypeValueTableLcopyValueFieldCallback`.
foreign import ccall "wrapper"
    mk_TypeValueTableLcopyValueFieldCallback :: C_TypeValueTableLcopyValueFieldCallback -> IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)

{- |
/No description available in the introspection data./
-}
type TypeValueTableLcopyValueFieldCallback =
    GValue
    -> Word32
    -> GObject.TypeCValue.TypeCValue
    -> Word32
    -> IO T.Text

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypeValueTableLcopyValueFieldCallback`@.
noTypeValueTableLcopyValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback
noTypeValueTableLcopyValueFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypeValueTableLcopyValueFieldCallback :: MonadIO m => TypeValueTableLcopyValueFieldCallback -> m (GClosure C_TypeValueTableLcopyValueFieldCallback)
genClosure_TypeValueTableLcopyValueFieldCallback cb = liftIO $ do
    let cb' = wrap_TypeValueTableLcopyValueFieldCallback Nothing cb
    mk_TypeValueTableLcopyValueFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypeValueTableLcopyValueFieldCallback` into a `C_TypeValueTableLcopyValueFieldCallback`.
wrap_TypeValueTableLcopyValueFieldCallback ::
    Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback)) ->
    TypeValueTableLcopyValueFieldCallback ->
    C_TypeValueTableLcopyValueFieldCallback
wrap_TypeValueTableLcopyValueFieldCallback funptrptr _cb value nCollectValues collectValues collectFlags = do
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        collectValues' <- (newPtr GObject.TypeCValue.TypeCValue) collectValues
        result <- _cb  value' nCollectValues collectValues' collectFlags
        maybeReleaseFunPtr funptrptr
        result' <- textToCString result
        return result'


-- callback TypeValueTableCollectValueFieldCallback
--          -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = False, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_collect_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collect_values", argType = TInterface (Name {namespace = "GObject", name = "TypeCValue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collect_flags", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableCollectValueFieldCallback =
    Ptr GValue ->
    Word32 ->
    Ptr GObject.TypeCValue.TypeCValue ->
    Word32 ->
    IO CString

-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_collect_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collect_values", argType = TInterface (Name {namespace = "GObject", name = "TypeCValue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "collect_flags", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypeValueTableCollectValueFieldCallback :: FunPtr C_TypeValueTableCollectValueFieldCallback -> C_TypeValueTableCollectValueFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypeValueTableCollectValueFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_TypeValueTableCollectValueFieldCallback
    -> GValue
    -> Word32
    -> GObject.TypeCValue.TypeCValue
    -> Word32
    -> m T.Text
dynamic_TypeValueTableCollectValueFieldCallback __funPtr value nCollectValues collectValues collectFlags = liftIO $ do
    value' <- unsafeManagedPtrGetPtr value
    collectValues' <- unsafeManagedPtrGetPtr collectValues
    result <- (__dynamic_C_TypeValueTableCollectValueFieldCallback __funPtr) value' nCollectValues collectValues' collectFlags
    checkUnexpectedReturnNULL "typeValueTableCollectValueFieldCallback" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr value
    touchManagedPtr collectValues
    return result'

-- | Generate a function pointer callable from C code, from a `C_TypeValueTableCollectValueFieldCallback`.
foreign import ccall "wrapper"
    mk_TypeValueTableCollectValueFieldCallback :: C_TypeValueTableCollectValueFieldCallback -> IO (FunPtr C_TypeValueTableCollectValueFieldCallback)

{- |
/No description available in the introspection data./
-}
type TypeValueTableCollectValueFieldCallback =
    GValue
    -> Word32
    -> GObject.TypeCValue.TypeCValue
    -> Word32
    -> IO T.Text

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypeValueTableCollectValueFieldCallback`@.
noTypeValueTableCollectValueFieldCallback :: Maybe TypeValueTableCollectValueFieldCallback
noTypeValueTableCollectValueFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypeValueTableCollectValueFieldCallback :: MonadIO m => TypeValueTableCollectValueFieldCallback -> m (GClosure C_TypeValueTableCollectValueFieldCallback)
genClosure_TypeValueTableCollectValueFieldCallback cb = liftIO $ do
    let cb' = wrap_TypeValueTableCollectValueFieldCallback Nothing cb
    mk_TypeValueTableCollectValueFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypeValueTableCollectValueFieldCallback` into a `C_TypeValueTableCollectValueFieldCallback`.
wrap_TypeValueTableCollectValueFieldCallback ::
    Maybe (Ptr (FunPtr C_TypeValueTableCollectValueFieldCallback)) ->
    TypeValueTableCollectValueFieldCallback ->
    C_TypeValueTableCollectValueFieldCallback
wrap_TypeValueTableCollectValueFieldCallback funptrptr _cb value nCollectValues collectValues collectFlags = do
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        collectValues' <- (newPtr GObject.TypeCValue.TypeCValue) collectValues
        result <- _cb  value' nCollectValues collectValues' collectFlags
        maybeReleaseFunPtr funptrptr
        result' <- textToCString result
        return result'


-- callback TypePluginUse
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "GObject", name = "TypePlugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypePlugin whose use count should be increased", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the @use_plugin function of #GTypePluginClass, which gets called\nto increase the use count of @plugin.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypePluginUse =
    Ptr GObject.TypePlugin.TypePlugin ->
    IO ()

-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "GObject", name = "TypePlugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypePlugin whose use count should be increased", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypePluginUse :: FunPtr C_TypePluginUse -> C_TypePluginUse

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypePluginUse ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.TypePlugin.IsTypePlugin a) =>
    FunPtr C_TypePluginUse
    -> a
    {- ^ /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' whose use count should be increased -}
    -> m ()
dynamic_TypePluginUse __funPtr plugin = liftIO $ do
    plugin' <- unsafeManagedPtrCastPtr plugin
    (__dynamic_C_TypePluginUse __funPtr) plugin'
    touchManagedPtr plugin
    return ()

-- | Generate a function pointer callable from C code, from a `C_TypePluginUse`.
foreign import ccall "wrapper"
    mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse)

{- |
The type of the /@usePlugin@/ function of @/GTypePluginClass/@, which gets called
to increase the use count of /@plugin@/.
-}
type TypePluginUse =
    GObject.TypePlugin.TypePlugin
    {- ^ /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' whose use count should be increased -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypePluginUse`@.
noTypePluginUse :: Maybe TypePluginUse
noTypePluginUse = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypePluginUse :: MonadIO m => TypePluginUse -> m (GClosure C_TypePluginUse)
genClosure_TypePluginUse cb = liftIO $ do
    let cb' = wrap_TypePluginUse Nothing cb
    mk_TypePluginUse cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypePluginUse` into a `C_TypePluginUse`.
wrap_TypePluginUse ::
    Maybe (Ptr (FunPtr C_TypePluginUse)) ->
    TypePluginUse ->
    C_TypePluginUse
wrap_TypePluginUse funptrptr _cb plugin = do
    plugin' <- (newPtr GObject.TypePlugin.TypePlugin) plugin
    _cb  plugin'
    maybeReleaseFunPtr funptrptr


-- callback TypePluginUnuse
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "GObject", name = "TypePlugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypePlugin whose use count should be decreased", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the @unuse_plugin function of #GTypePluginClass.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypePluginUnuse =
    Ptr GObject.TypePlugin.TypePlugin ->
    IO ()

-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "GObject", name = "TypePlugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypePlugin whose use count should be decreased", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypePluginUnuse :: FunPtr C_TypePluginUnuse -> C_TypePluginUnuse

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypePluginUnuse ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.TypePlugin.IsTypePlugin a) =>
    FunPtr C_TypePluginUnuse
    -> a
    {- ^ /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' whose use count should be decreased -}
    -> m ()
dynamic_TypePluginUnuse __funPtr plugin = liftIO $ do
    plugin' <- unsafeManagedPtrCastPtr plugin
    (__dynamic_C_TypePluginUnuse __funPtr) plugin'
    touchManagedPtr plugin
    return ()

-- | Generate a function pointer callable from C code, from a `C_TypePluginUnuse`.
foreign import ccall "wrapper"
    mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse)

{- |
The type of the /@unusePlugin@/ function of @/GTypePluginClass/@.
-}
type TypePluginUnuse =
    GObject.TypePlugin.TypePlugin
    {- ^ /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' whose use count should be decreased -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypePluginUnuse`@.
noTypePluginUnuse :: Maybe TypePluginUnuse
noTypePluginUnuse = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypePluginUnuse :: MonadIO m => TypePluginUnuse -> m (GClosure C_TypePluginUnuse)
genClosure_TypePluginUnuse cb = liftIO $ do
    let cb' = wrap_TypePluginUnuse Nothing cb
    mk_TypePluginUnuse cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypePluginUnuse` into a `C_TypePluginUnuse`.
wrap_TypePluginUnuse ::
    Maybe (Ptr (FunPtr C_TypePluginUnuse)) ->
    TypePluginUnuse ->
    C_TypePluginUnuse
wrap_TypePluginUnuse funptrptr _cb plugin = do
    plugin' <- (newPtr GObject.TypePlugin.TypePlugin) plugin
    _cb  plugin'
    maybeReleaseFunPtr funptrptr


-- callback TypePluginCompleteTypeInfo
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "GObject", name = "TypePlugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypePlugin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType whose info is completed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GObject", name = "TypeInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypeInfo struct to fill in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value_table", argType = TInterface (Name {namespace = "GObject", name = "TypeValueTable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypeValueTable to fill in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the @complete_type_info function of #GTypePluginClass.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypePluginCompleteTypeInfo =
    Ptr GObject.TypePlugin.TypePlugin ->
    CGType ->
    Ptr GObject.TypeInfo.TypeInfo ->
    Ptr GObject.TypeValueTable.TypeValueTable ->
    IO ()

-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "GObject", name = "TypePlugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypePlugin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType whose info is completed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GObject", name = "TypeInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypeInfo struct to fill in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value_table", argType = TInterface (Name {namespace = "GObject", name = "TypeValueTable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypeValueTable to fill in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypePluginCompleteTypeInfo :: FunPtr C_TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypePluginCompleteTypeInfo ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.TypePlugin.IsTypePlugin a) =>
    FunPtr C_TypePluginCompleteTypeInfo
    -> a
    {- ^ /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' -}
    -> GType
    {- ^ /@gType@/: the 'GType' whose info is completed -}
    -> GObject.TypeInfo.TypeInfo
    {- ^ /@info@/: the 'GI.GObject.Structs.TypeInfo.TypeInfo' struct to fill in -}
    -> GObject.TypeValueTable.TypeValueTable
    {- ^ /@valueTable@/: the 'GI.GObject.Structs.TypeValueTable.TypeValueTable' to fill in -}
    -> m ()
dynamic_TypePluginCompleteTypeInfo __funPtr plugin gType info valueTable = liftIO $ do
    plugin' <- unsafeManagedPtrCastPtr plugin
    let gType' = gtypeToCGType gType
    info' <- unsafeManagedPtrGetPtr info
    valueTable' <- unsafeManagedPtrGetPtr valueTable
    (__dynamic_C_TypePluginCompleteTypeInfo __funPtr) plugin' gType' info' valueTable'
    touchManagedPtr plugin
    touchManagedPtr info
    touchManagedPtr valueTable
    return ()

-- | Generate a function pointer callable from C code, from a `C_TypePluginCompleteTypeInfo`.
foreign import ccall "wrapper"
    mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo)

{- |
The type of the /@completeTypeInfo@/ function of @/GTypePluginClass/@.
-}
type TypePluginCompleteTypeInfo =
    GObject.TypePlugin.TypePlugin
    {- ^ /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' -}
    -> GType
    {- ^ /@gType@/: the 'GType' whose info is completed -}
    -> GObject.TypeInfo.TypeInfo
    {- ^ /@info@/: the 'GI.GObject.Structs.TypeInfo.TypeInfo' struct to fill in -}
    -> GObject.TypeValueTable.TypeValueTable
    {- ^ /@valueTable@/: the 'GI.GObject.Structs.TypeValueTable.TypeValueTable' to fill in -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypePluginCompleteTypeInfo`@.
noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo
noTypePluginCompleteTypeInfo = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypePluginCompleteTypeInfo :: MonadIO m => TypePluginCompleteTypeInfo -> m (GClosure C_TypePluginCompleteTypeInfo)
genClosure_TypePluginCompleteTypeInfo cb = liftIO $ do
    let cb' = wrap_TypePluginCompleteTypeInfo Nothing cb
    mk_TypePluginCompleteTypeInfo cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypePluginCompleteTypeInfo` into a `C_TypePluginCompleteTypeInfo`.
wrap_TypePluginCompleteTypeInfo ::
    Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) ->
    TypePluginCompleteTypeInfo ->
    C_TypePluginCompleteTypeInfo
wrap_TypePluginCompleteTypeInfo funptrptr _cb plugin gType info valueTable = do
    plugin' <- (newPtr GObject.TypePlugin.TypePlugin) plugin
    let gType' = GType gType
    info' <- (newPtr GObject.TypeInfo.TypeInfo) info
    valueTable' <- (newPtr GObject.TypeValueTable.TypeValueTable) valueTable
    _cb  plugin' gType' info' valueTable'
    maybeReleaseFunPtr funptrptr


-- callback TypePluginCompleteInterfaceInfo
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "GObject", name = "TypePlugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypePlugin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of an instantiable type to which the interface\n is added", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the interface whose info is completed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GObject", name = "InterfaceInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GInterfaceInfo to fill in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the @complete_interface_info function of #GTypePluginClass.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypePluginCompleteInterfaceInfo =
    Ptr GObject.TypePlugin.TypePlugin ->
    CGType ->
    CGType ->
    Ptr GObject.InterfaceInfo.InterfaceInfo ->
    IO ()

-- Args : [Arg {argCName = "plugin", argType = TInterface (Name {namespace = "GObject", name = "TypePlugin"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTypePlugin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of an instantiable type to which the interface\n is added", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the interface whose info is completed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GObject", name = "InterfaceInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GInterfaceInfo to fill in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypePluginCompleteInterfaceInfo :: FunPtr C_TypePluginCompleteInterfaceInfo -> C_TypePluginCompleteInterfaceInfo

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypePluginCompleteInterfaceInfo ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.TypePlugin.IsTypePlugin a) =>
    FunPtr C_TypePluginCompleteInterfaceInfo
    -> a
    {- ^ /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' -}
    -> GType
    {- ^ /@instanceType@/: the 'GType' of an instantiable type to which the interface
 is added -}
    -> GType
    {- ^ /@interfaceType@/: the 'GType' of the interface whose info is completed -}
    -> GObject.InterfaceInfo.InterfaceInfo
    {- ^ /@info@/: the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' to fill in -}
    -> m ()
dynamic_TypePluginCompleteInterfaceInfo __funPtr plugin instanceType interfaceType info = liftIO $ do
    plugin' <- unsafeManagedPtrCastPtr plugin
    let instanceType' = gtypeToCGType instanceType
    let interfaceType' = gtypeToCGType interfaceType
    info' <- unsafeManagedPtrGetPtr info
    (__dynamic_C_TypePluginCompleteInterfaceInfo __funPtr) plugin' instanceType' interfaceType' info'
    touchManagedPtr plugin
    touchManagedPtr info
    return ()

-- | Generate a function pointer callable from C code, from a `C_TypePluginCompleteInterfaceInfo`.
foreign import ccall "wrapper"
    mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo)

{- |
The type of the /@completeInterfaceInfo@/ function of @/GTypePluginClass/@.
-}
type TypePluginCompleteInterfaceInfo =
    GObject.TypePlugin.TypePlugin
    {- ^ /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' -}
    -> GType
    {- ^ /@instanceType@/: the 'GType' of an instantiable type to which the interface
 is added -}
    -> GType
    {- ^ /@interfaceType@/: the 'GType' of the interface whose info is completed -}
    -> GObject.InterfaceInfo.InterfaceInfo
    {- ^ /@info@/: the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' to fill in -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypePluginCompleteInterfaceInfo`@.
noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo
noTypePluginCompleteInterfaceInfo = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypePluginCompleteInterfaceInfo :: MonadIO m => TypePluginCompleteInterfaceInfo -> m (GClosure C_TypePluginCompleteInterfaceInfo)
genClosure_TypePluginCompleteInterfaceInfo cb = liftIO $ do
    let cb' = wrap_TypePluginCompleteInterfaceInfo Nothing cb
    mk_TypePluginCompleteInterfaceInfo cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypePluginCompleteInterfaceInfo` into a `C_TypePluginCompleteInterfaceInfo`.
wrap_TypePluginCompleteInterfaceInfo ::
    Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) ->
    TypePluginCompleteInterfaceInfo ->
    C_TypePluginCompleteInterfaceInfo
wrap_TypePluginCompleteInterfaceInfo funptrptr _cb plugin instanceType interfaceType info = do
    plugin' <- (newPtr GObject.TypePlugin.TypePlugin) plugin
    let instanceType' = GType instanceType
    let interfaceType' = GType interfaceType
    info' <- (newPtr GObject.InterfaceInfo.InterfaceInfo) info
    _cb  plugin' instanceType' interfaceType' info'
    maybeReleaseFunPtr funptrptr


-- callback TypeInterfaceCheckFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "check_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data passed to g_type_add_interface_check()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g_iface", argType = TInterface (Name {namespace = "GObject", name = "TypeInterface"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the interface that has been\n   initialized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback called after an interface vtable is initialized.\nSee g_type_add_interface_check().", sinceVersion = Just "2.4"}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypeInterfaceCheckFunc =
    Ptr () ->
    Ptr GObject.TypeInterface.TypeInterface ->
    IO ()

-- Args : [Arg {argCName = "check_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data passed to g_type_add_interface_check()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g_iface", argType = TInterface (Name {namespace = "GObject", name = "TypeInterface"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the interface that has been\n   initialized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypeInterfaceCheckFunc :: FunPtr C_TypeInterfaceCheckFunc -> C_TypeInterfaceCheckFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypeInterfaceCheckFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_TypeInterfaceCheckFunc
    -> Ptr ()
    {- ^ /@checkData@/: data passed to @/g_type_add_interface_check()/@ -}
    -> GObject.TypeInterface.TypeInterface
    {- ^ /@gIface@/: the interface that has been
   initialized -}
    -> m ()
dynamic_TypeInterfaceCheckFunc __funPtr checkData gIface = liftIO $ do
    gIface' <- unsafeManagedPtrGetPtr gIface
    (__dynamic_C_TypeInterfaceCheckFunc __funPtr) checkData gIface'
    touchManagedPtr gIface
    return ()

-- | Generate a function pointer callable from C code, from a `C_TypeInterfaceCheckFunc`.
foreign import ccall "wrapper"
    mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)

{- |
A callback called after an interface vtable is initialized.
See @/g_type_add_interface_check()/@.

/Since: 2.4/
-}
type TypeInterfaceCheckFunc =
    Ptr ()
    {- ^ /@checkData@/: data passed to @/g_type_add_interface_check()/@ -}
    -> GObject.TypeInterface.TypeInterface
    {- ^ /@gIface@/: the interface that has been
   initialized -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypeInterfaceCheckFunc`@.
noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc
noTypeInterfaceCheckFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypeInterfaceCheckFunc :: MonadIO m => TypeInterfaceCheckFunc -> m (GClosure C_TypeInterfaceCheckFunc)
genClosure_TypeInterfaceCheckFunc cb = liftIO $ do
    let cb' = wrap_TypeInterfaceCheckFunc Nothing cb
    mk_TypeInterfaceCheckFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypeInterfaceCheckFunc` into a `C_TypeInterfaceCheckFunc`.
wrap_TypeInterfaceCheckFunc ::
    Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc)) ->
    TypeInterfaceCheckFunc ->
    C_TypeInterfaceCheckFunc
wrap_TypeInterfaceCheckFunc funptrptr _cb checkData gIface = do
    gIface' <- (newPtr GObject.TypeInterface.TypeInterface) gIface
    _cb  checkData gIface'
    maybeReleaseFunPtr funptrptr


-- callback TypeClassCacheFunc
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE to stop further #GTypeClassCacheFuncs from being\n called, %FALSE to continue", sinceVersion = Nothing}, args = [Arg {argCName = "cache_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data that was given to the g_type_add_class_cache_func() call", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure which is\n   unreferenced", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function which is called when the reference count of a class\ndrops to zero. It may use g_type_class_ref() to prevent the class from\nbeing freed. You should not call g_type_class_unref() from a\n#GTypeClassCacheFunc function to prevent infinite recursion, use\ng_type_class_unref_uncached() instead.\n\nThe functions have to check the class id passed in to figure\nwhether they actually want to cache the class of this type, since all\nclasses are routed through the same #GTypeClassCacheFunc chain.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_TypeClassCacheFunc =
    Ptr () ->
    Ptr GObject.TypeClass.TypeClass ->
    IO CInt

-- Args : [Arg {argCName = "cache_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data that was given to the g_type_add_class_cache_func() call", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure which is\n   unreferenced", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_TypeClassCacheFunc :: FunPtr C_TypeClassCacheFunc -> C_TypeClassCacheFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_TypeClassCacheFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_TypeClassCacheFunc
    -> Ptr ()
    {- ^ /@cacheData@/: data that was given to the @/g_type_add_class_cache_func()/@ call -}
    -> GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure which is
   unreferenced -}
    -> m Bool
    {- ^ __Returns:__ 'True' to stop further @/GTypeClassCacheFuncs/@ from being
 called, 'False' to continue -}
dynamic_TypeClassCacheFunc __funPtr cacheData gClass = liftIO $ do
    gClass' <- unsafeManagedPtrGetPtr gClass
    result <- (__dynamic_C_TypeClassCacheFunc __funPtr) cacheData gClass'
    let result' = (/= 0) result
    touchManagedPtr gClass
    return result'

-- | Generate a function pointer callable from C code, from a `C_TypeClassCacheFunc`.
foreign import ccall "wrapper"
    mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)

{- |
A callback function which is called when the reference count of a class
drops to zero. It may use 'GI.GObject.Functions.typeClassRef' to prevent the class from
being freed. You should not call 'GI.GObject.Structs.TypeClass.typeClassUnref' from a
'GI.GObject.Callbacks.TypeClassCacheFunc' function to prevent infinite recursion, use
@/g_type_class_unref_uncached()/@ instead.

The functions have to check the class id passed in to figure
whether they actually want to cache the class of this type, since all
classes are routed through the same 'GI.GObject.Callbacks.TypeClassCacheFunc' chain.
-}
type TypeClassCacheFunc =
    Ptr ()
    {- ^ /@cacheData@/: data that was given to the @/g_type_add_class_cache_func()/@ call -}
    -> GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure which is
   unreferenced -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop further @/GTypeClassCacheFuncs/@ from being
 called, 'False' to continue -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `TypeClassCacheFunc`@.
noTypeClassCacheFunc :: Maybe TypeClassCacheFunc
noTypeClassCacheFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_TypeClassCacheFunc :: MonadIO m => TypeClassCacheFunc -> m (GClosure C_TypeClassCacheFunc)
genClosure_TypeClassCacheFunc cb = liftIO $ do
    let cb' = wrap_TypeClassCacheFunc Nothing cb
    mk_TypeClassCacheFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `TypeClassCacheFunc` into a `C_TypeClassCacheFunc`.
wrap_TypeClassCacheFunc ::
    Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) ->
    TypeClassCacheFunc ->
    C_TypeClassCacheFunc
wrap_TypeClassCacheFunc funptrptr _cb cacheData gClass = do
    gClass' <- (newPtr GObject.TypeClass.TypeClass) gClass
    result <- _cb  cacheData gClass'
    maybeReleaseFunPtr funptrptr
    let result' = (fromIntegral . fromEnum) result
    return result'


-- callback ToggleNotify
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Callback data passed to g_object_add_toggle_ref()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The object on which g_object_add_toggle_ref() was called.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_last_ref", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the toggle reference is now the\n last reference to the object. %FALSE if the toggle\n reference was the last reference and there are now other\n references.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function used for notification when the state\nof a toggle reference changes. See g_object_add_toggle_ref().", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ToggleNotify =
    Ptr () ->
    Ptr GObject.Object.Object ->
    CInt ->
    IO ()

-- Args : [Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Callback data passed to g_object_add_toggle_ref()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The object on which g_object_add_toggle_ref() was called.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_last_ref", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the toggle reference is now the\n last reference to the object. %FALSE if the toggle\n reference was the last reference and there are now other\n references.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ToggleNotify :: FunPtr C_ToggleNotify -> C_ToggleNotify

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ToggleNotify ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
    FunPtr C_ToggleNotify
    -> Ptr ()
    {- ^ /@data@/: Callback data passed to @/g_object_add_toggle_ref()/@ -}
    -> a
    {- ^ /@object@/: The object on which @/g_object_add_toggle_ref()/@ was called. -}
    -> Bool
    {- ^ /@isLastRef@/: 'True' if the toggle reference is now the
 last reference to the object. 'False' if the toggle
 reference was the last reference and there are now other
 references. -}
    -> m ()
dynamic_ToggleNotify __funPtr data_ object isLastRef = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    let isLastRef' = (fromIntegral . fromEnum) isLastRef
    (__dynamic_C_ToggleNotify __funPtr) data_ object' isLastRef'
    touchManagedPtr object
    return ()

-- | Generate a function pointer callable from C code, from a `C_ToggleNotify`.
foreign import ccall "wrapper"
    mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify)

{- |
A callback function used for notification when the state
of a toggle reference changes. See @/g_object_add_toggle_ref()/@.
-}
type ToggleNotify =
    Ptr ()
    {- ^ /@data@/: Callback data passed to @/g_object_add_toggle_ref()/@ -}
    -> GObject.Object.Object
    {- ^ /@object@/: The object on which @/g_object_add_toggle_ref()/@ was called. -}
    -> Bool
    {- ^ /@isLastRef@/: 'True' if the toggle reference is now the
 last reference to the object. 'False' if the toggle
 reference was the last reference and there are now other
 references. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ToggleNotify`@.
noToggleNotify :: Maybe ToggleNotify
noToggleNotify = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ToggleNotify :: MonadIO m => ToggleNotify -> m (GClosure C_ToggleNotify)
genClosure_ToggleNotify cb = liftIO $ do
    let cb' = wrap_ToggleNotify Nothing cb
    mk_ToggleNotify cb' >>= B.GClosure.newGClosure


-- | Wrap a `ToggleNotify` into a `C_ToggleNotify`.
wrap_ToggleNotify ::
    Maybe (Ptr (FunPtr C_ToggleNotify)) ->
    ToggleNotify ->
    C_ToggleNotify
wrap_ToggleNotify funptrptr _cb data_ object isLastRef = do
    object' <- (newObject GObject.Object.Object) object
    let isLastRef' = (/= 0) isLastRef
    _cb  data_ object' isLastRef'
    maybeReleaseFunPtr funptrptr


-- callback SignalEmissionHook
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "whether it wants to stay connected. If it returns %FALSE, the signal\n hook is disconnected (and destroyed).", sinceVersion = Nothing}, args = [Arg {argCName = "ihint", argType = TInterface (Name {namespace = "GObject", name = "SignalInvocationHint"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Signal invocation hint, see #GSignalInvocationHint.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_param_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters to the function, including\n the instance on which the signal was emitted.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "param_values", argType = TCArray False (-1) 1 (TInterface (Name {namespace = "GObject", name = "Value"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the instance on which\n the signal was emitted, followed by the parameters of the emission.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data associated with the hook.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A simple function pointer to get invoked when the signal is emitted. This\nallows you to tie a hook to the signal type, so that it will trap all\nemissions of that signal, from any object.\n\nYou may not attach these to signals created with the #G_SIGNAL_NO_HOOKS flag.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_SignalEmissionHook =
    Ptr GObject.SignalInvocationHint.SignalInvocationHint ->
    Word32 ->
    Ptr GValue ->
    Ptr () ->
    IO CInt

-- Args : [Arg {argCName = "ihint", argType = TInterface (Name {namespace = "GObject", name = "SignalInvocationHint"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Signal invocation hint, see #GSignalInvocationHint.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_param_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters to the function, including\n the instance on which the signal was emitted.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "param_values", argType = TCArray False (-1) 1 (TInterface (Name {namespace = "GObject", name = "Value"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the instance on which\n the signal was emitted, followed by the parameters of the emission.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data associated with the hook.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "n_param_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters to the function, including\n the instance on which the signal was emitted.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SignalEmissionHook :: FunPtr C_SignalEmissionHook -> C_SignalEmissionHook

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SignalEmissionHook ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_SignalEmissionHook
    -> GObject.SignalInvocationHint.SignalInvocationHint
    {- ^ /@ihint@/: Signal invocation hint, see 'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. -}
    -> [GValue]
    {- ^ /@paramValues@/: the instance on which
 the signal was emitted, followed by the parameters of the emission. -}
    -> Ptr ()
    {- ^ /@data@/: user data associated with the hook. -}
    -> m Bool
    {- ^ __Returns:__ whether it wants to stay connected. If it returns 'False', the signal
 hook is disconnected (and destroyed). -}
dynamic_SignalEmissionHook __funPtr ihint paramValues data_ = liftIO $ do
    let nParamValues = fromIntegral $ length paramValues
    ihint' <- unsafeManagedPtrGetPtr ihint
    paramValues' <- mapM unsafeManagedPtrGetPtr paramValues
    paramValues'' <- packBlockArray 24 paramValues'
    result <- (__dynamic_C_SignalEmissionHook __funPtr) ihint' nParamValues paramValues'' data_
    let result' = (/= 0) result
    touchManagedPtr ihint
    mapM_ touchManagedPtr paramValues
    freeMem paramValues''
    return result'

-- | Generate a function pointer callable from C code, from a `C_SignalEmissionHook`.
foreign import ccall "wrapper"
    mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)

{- |
A simple function pointer to get invoked when the signal is emitted. This
allows you to tie a hook to the signal type, so that it will trap all
emissions of that signal, from any object.

You may not attach these to signals created with the @/G_SIGNAL_NO_HOOKS/@ flag.
-}
type SignalEmissionHook =
    GObject.SignalInvocationHint.SignalInvocationHint
    {- ^ /@ihint@/: Signal invocation hint, see 'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. -}
    -> [GValue]
    {- ^ /@paramValues@/: the instance on which
 the signal was emitted, followed by the parameters of the emission. -}
    -> Ptr ()
    {- ^ /@data@/: user data associated with the hook. -}
    -> IO Bool
    {- ^ __Returns:__ whether it wants to stay connected. If it returns 'False', the signal
 hook is disconnected (and destroyed). -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `SignalEmissionHook`@.
noSignalEmissionHook :: Maybe SignalEmissionHook
noSignalEmissionHook = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_SignalEmissionHook :: MonadIO m => SignalEmissionHook -> m (GClosure C_SignalEmissionHook)
genClosure_SignalEmissionHook cb = liftIO $ do
    let cb' = wrap_SignalEmissionHook Nothing cb
    mk_SignalEmissionHook cb' >>= B.GClosure.newGClosure


-- | Wrap a `SignalEmissionHook` into a `C_SignalEmissionHook`.
wrap_SignalEmissionHook ::
    Maybe (Ptr (FunPtr C_SignalEmissionHook)) ->
    SignalEmissionHook ->
    C_SignalEmissionHook
wrap_SignalEmissionHook funptrptr _cb ihint nParamValues paramValues data_ = do
    ihint' <- (newPtr GObject.SignalInvocationHint.SignalInvocationHint) ihint
    paramValues' <- (unpackBoxedArrayWithLength 24 nParamValues) paramValues
    paramValues'' <- mapM (newBoxed GValue) paramValues'
    result <- _cb  ihint' paramValues'' data_
    maybeReleaseFunPtr funptrptr
    let result' = (fromIntegral . fromEnum) result
    return result'


-- callback SignalAccumulator
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "The accumulator function returns whether the signal emission\n should be aborted. Returning %FALSE means to abort the\n current emission and %TRUE is returned for continuation.", sinceVersion = Nothing}, args = [Arg {argCName = "ihint", argType = TInterface (Name {namespace = "GObject", name = "SignalInvocationHint"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Signal invocation hint, see #GSignalInvocationHint.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_accu", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Accumulator to collect callback return values in, this\n is the return value of the current signal emission.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handler_return", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GValue holding the return value of the signal handler.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Callback data that was specified when creating the signal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The signal accumulator is a special callback function that can be used\nto collect return values of the various callbacks that are called\nduring a signal emission. The signal accumulator is specified at signal\ncreation time, if it is left %NULL, no accumulation of callback return\nvalues is performed. The return value of signal emissions is then the\nvalue returned by the last callback.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_SignalAccumulator =
    Ptr GObject.SignalInvocationHint.SignalInvocationHint ->
    Ptr GValue ->
    Ptr GValue ->
    Ptr () ->
    IO CInt

-- Args : [Arg {argCName = "ihint", argType = TInterface (Name {namespace = "GObject", name = "SignalInvocationHint"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Signal invocation hint, see #GSignalInvocationHint.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_accu", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Accumulator to collect callback return values in, this\n is the return value of the current signal emission.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handler_return", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GValue holding the return value of the signal handler.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Callback data that was specified when creating the signal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SignalAccumulator :: FunPtr C_SignalAccumulator -> C_SignalAccumulator

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SignalAccumulator ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_SignalAccumulator
    -> GObject.SignalInvocationHint.SignalInvocationHint
    {- ^ /@ihint@/: Signal invocation hint, see 'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. -}
    -> GValue
    {- ^ /@returnAccu@/: Accumulator to collect callback return values in, this
 is the return value of the current signal emission. -}
    -> GValue
    {- ^ /@handlerReturn@/: A 'GI.GObject.Structs.Value.Value' holding the return value of the signal handler. -}
    -> Ptr ()
    {- ^ /@data@/: Callback data that was specified when creating the signal. -}
    -> m Bool
    {- ^ __Returns:__ The accumulator function returns whether the signal emission
 should be aborted. Returning 'False' means to abort the
 current emission and 'True' is returned for continuation. -}
dynamic_SignalAccumulator __funPtr ihint returnAccu handlerReturn data_ = liftIO $ do
    ihint' <- unsafeManagedPtrGetPtr ihint
    returnAccu' <- unsafeManagedPtrGetPtr returnAccu
    handlerReturn' <- unsafeManagedPtrGetPtr handlerReturn
    result <- (__dynamic_C_SignalAccumulator __funPtr) ihint' returnAccu' handlerReturn' data_
    let result' = (/= 0) result
    touchManagedPtr ihint
    touchManagedPtr returnAccu
    touchManagedPtr handlerReturn
    return result'

-- | Generate a function pointer callable from C code, from a `C_SignalAccumulator`.
foreign import ccall "wrapper"
    mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)

{- |
The signal accumulator is a special callback function that can be used
to collect return values of the various callbacks that are called
during a signal emission. The signal accumulator is specified at signal
creation time, if it is left 'Nothing', no accumulation of callback return
values is performed. The return value of signal emissions is then the
value returned by the last callback.
-}
type SignalAccumulator =
    GObject.SignalInvocationHint.SignalInvocationHint
    {- ^ /@ihint@/: Signal invocation hint, see 'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. -}
    -> GValue
    {- ^ /@returnAccu@/: Accumulator to collect callback return values in, this
 is the return value of the current signal emission. -}
    -> GValue
    {- ^ /@handlerReturn@/: A 'GI.GObject.Structs.Value.Value' holding the return value of the signal handler. -}
    -> Ptr ()
    {- ^ /@data@/: Callback data that was specified when creating the signal. -}
    -> IO Bool
    {- ^ __Returns:__ The accumulator function returns whether the signal emission
 should be aborted. Returning 'False' means to abort the
 current emission and 'True' is returned for continuation. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `SignalAccumulator`@.
noSignalAccumulator :: Maybe SignalAccumulator
noSignalAccumulator = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_SignalAccumulator :: MonadIO m => SignalAccumulator -> m (GClosure C_SignalAccumulator)
genClosure_SignalAccumulator cb = liftIO $ do
    let cb' = wrap_SignalAccumulator Nothing cb
    mk_SignalAccumulator cb' >>= B.GClosure.newGClosure


-- | Wrap a `SignalAccumulator` into a `C_SignalAccumulator`.
wrap_SignalAccumulator ::
    Maybe (Ptr (FunPtr C_SignalAccumulator)) ->
    SignalAccumulator ->
    C_SignalAccumulator
wrap_SignalAccumulator funptrptr _cb ihint returnAccu handlerReturn data_ = do
    ihint' <- (newPtr GObject.SignalInvocationHint.SignalInvocationHint) ihint
    B.ManagedPtr.withTransient GValue returnAccu $ \returnAccu' -> do
        B.ManagedPtr.withTransient GValue handlerReturn $ \handlerReturn' -> do
            result <- _cb  ihint' returnAccu' handlerReturn' data_
            maybeReleaseFunPtr funptrptr
            let result' = (fromIntegral . fromEnum) result
            return result'


-- callback ParamSpecTypeInfoValuesCmpFieldCallback
--          -> Callable {returnType = Just (TBasicType TInt), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value1", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoValuesCmpFieldCallback =
    Ptr GParamSpec ->
    Ptr GValue ->
    Ptr GValue ->
    IO Int32

-- Args : [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value1", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoValuesCmpFieldCallback :: FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> C_ParamSpecTypeInfoValuesCmpFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ParamSpecTypeInfoValuesCmpFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback
    -> GParamSpec
    -> GValue
    -> GValue
    -> m Int32
dynamic_ParamSpecTypeInfoValuesCmpFieldCallback __funPtr pspec value1 value2 = liftIO $ do
    pspec' <- unsafeManagedPtrGetPtr pspec
    value1' <- unsafeManagedPtrGetPtr value1
    value2' <- unsafeManagedPtrGetPtr value2
    result <- (__dynamic_C_ParamSpecTypeInfoValuesCmpFieldCallback __funPtr) pspec' value1' value2'
    touchManagedPtr pspec
    touchManagedPtr value1
    touchManagedPtr value2
    return result

-- | Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoValuesCmpFieldCallback`.
foreign import ccall "wrapper"
    mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)

{- |
/No description available in the introspection data./
-}
type ParamSpecTypeInfoValuesCmpFieldCallback =
    GParamSpec
    -> GValue
    -> GValue
    -> IO Int32

-- | A convenience synonym for @`Nothing` :: `Maybe` `ParamSpecTypeInfoValuesCmpFieldCallback`@.
noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback
noParamSpecTypeInfoValuesCmpFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: MonadIO m => ParamSpecTypeInfoValuesCmpFieldCallback -> m (GClosure C_ParamSpecTypeInfoValuesCmpFieldCallback)
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback cb = liftIO $ do
    let cb' = wrap_ParamSpecTypeInfoValuesCmpFieldCallback Nothing cb
    mk_ParamSpecTypeInfoValuesCmpFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ParamSpecTypeInfoValuesCmpFieldCallback` into a `C_ParamSpecTypeInfoValuesCmpFieldCallback`.
wrap_ParamSpecTypeInfoValuesCmpFieldCallback ::
    Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)) ->
    ParamSpecTypeInfoValuesCmpFieldCallback ->
    C_ParamSpecTypeInfoValuesCmpFieldCallback
wrap_ParamSpecTypeInfoValuesCmpFieldCallback funptrptr _cb pspec value1 value2 = do
    pspec' <- B.GParamSpec.newGParamSpecFromPtr pspec
    B.ManagedPtr.withTransient GValue value1 $ \value1' -> do
        B.ManagedPtr.withTransient GValue value2 $ \value2' -> do
            result <- _cb  pspec' value1' value2'
            maybeReleaseFunPtr funptrptr
            return result


-- callback ParamSpecTypeInfoValueValidateFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoValueValidateFieldCallback =
    Ptr GParamSpec ->
    Ptr GValue ->
    IO CInt

-- Args : [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoValueValidateFieldCallback :: FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> C_ParamSpecTypeInfoValueValidateFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ParamSpecTypeInfoValueValidateFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback
    -> GParamSpec
    -> GValue
    -> m Bool
dynamic_ParamSpecTypeInfoValueValidateFieldCallback __funPtr pspec value = liftIO $ do
    pspec' <- unsafeManagedPtrGetPtr pspec
    value' <- unsafeManagedPtrGetPtr value
    result <- (__dynamic_C_ParamSpecTypeInfoValueValidateFieldCallback __funPtr) pspec' value'
    let result' = (/= 0) result
    touchManagedPtr pspec
    touchManagedPtr value
    return result'

-- | Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoValueValidateFieldCallback`.
foreign import ccall "wrapper"
    mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)

{- |
/No description available in the introspection data./
-}
type ParamSpecTypeInfoValueValidateFieldCallback =
    GParamSpec
    -> GValue
    -> IO Bool

-- | A convenience synonym for @`Nothing` :: `Maybe` `ParamSpecTypeInfoValueValidateFieldCallback`@.
noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback
noParamSpecTypeInfoValueValidateFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: MonadIO m => ParamSpecTypeInfoValueValidateFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueValidateFieldCallback)
genClosure_ParamSpecTypeInfoValueValidateFieldCallback cb = liftIO $ do
    let cb' = wrap_ParamSpecTypeInfoValueValidateFieldCallback Nothing cb
    mk_ParamSpecTypeInfoValueValidateFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ParamSpecTypeInfoValueValidateFieldCallback` into a `C_ParamSpecTypeInfoValueValidateFieldCallback`.
wrap_ParamSpecTypeInfoValueValidateFieldCallback ::
    Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)) ->
    ParamSpecTypeInfoValueValidateFieldCallback ->
    C_ParamSpecTypeInfoValueValidateFieldCallback
wrap_ParamSpecTypeInfoValueValidateFieldCallback funptrptr _cb pspec value = do
    pspec' <- B.GParamSpec.newGParamSpecFromPtr pspec
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        result <- _cb  pspec' value'
        maybeReleaseFunPtr funptrptr
        let result' = (fromIntegral . fromEnum) result
        return result'


-- callback ParamSpecTypeInfoValueSetDefaultFieldCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoValueSetDefaultFieldCallback =
    Ptr GParamSpec ->
    Ptr GValue ->
    IO ()

-- Args : [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoValueSetDefaultFieldCallback :: FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> C_ParamSpecTypeInfoValueSetDefaultFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback
    -> GParamSpec
    -> GValue
    -> m ()
dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback __funPtr pspec value = liftIO $ do
    pspec' <- unsafeManagedPtrGetPtr pspec
    value' <- unsafeManagedPtrGetPtr value
    (__dynamic_C_ParamSpecTypeInfoValueSetDefaultFieldCallback __funPtr) pspec' value'
    touchManagedPtr pspec
    touchManagedPtr value
    return ()

-- | Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoValueSetDefaultFieldCallback`.
foreign import ccall "wrapper"
    mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)

{- |
/No description available in the introspection data./
-}
type ParamSpecTypeInfoValueSetDefaultFieldCallback =
    GParamSpec
    -> GValue
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ParamSpecTypeInfoValueSetDefaultFieldCallback`@.
noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback
noParamSpecTypeInfoValueSetDefaultFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: MonadIO m => ParamSpecTypeInfoValueSetDefaultFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback cb = liftIO $ do
    let cb' = wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback Nothing cb
    mk_ParamSpecTypeInfoValueSetDefaultFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ParamSpecTypeInfoValueSetDefaultFieldCallback` into a `C_ParamSpecTypeInfoValueSetDefaultFieldCallback`.
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback ::
    Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)) ->
    ParamSpecTypeInfoValueSetDefaultFieldCallback ->
    C_ParamSpecTypeInfoValueSetDefaultFieldCallback
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback funptrptr _cb pspec value = do
    pspec' <- B.GParamSpec.newGParamSpecFromPtr pspec
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        _cb  pspec' value'
        maybeReleaseFunPtr funptrptr


-- callback ParamSpecTypeInfoInstanceInitFieldCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoInstanceInitFieldCallback =
    Ptr GParamSpec ->
    IO ()

-- Args : [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoInstanceInitFieldCallback :: FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> C_ParamSpecTypeInfoInstanceInitFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ParamSpecTypeInfoInstanceInitFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback
    -> GParamSpec
    -> m ()
dynamic_ParamSpecTypeInfoInstanceInitFieldCallback __funPtr pspec = liftIO $ do
    pspec' <- unsafeManagedPtrGetPtr pspec
    (__dynamic_C_ParamSpecTypeInfoInstanceInitFieldCallback __funPtr) pspec'
    touchManagedPtr pspec
    return ()

-- | Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoInstanceInitFieldCallback`.
foreign import ccall "wrapper"
    mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)

{- |
/No description available in the introspection data./
-}
type ParamSpecTypeInfoInstanceInitFieldCallback =
    GParamSpec
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ParamSpecTypeInfoInstanceInitFieldCallback`@.
noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback
noParamSpecTypeInfoInstanceInitFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: MonadIO m => ParamSpecTypeInfoInstanceInitFieldCallback -> m (GClosure C_ParamSpecTypeInfoInstanceInitFieldCallback)
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback cb = liftIO $ do
    let cb' = wrap_ParamSpecTypeInfoInstanceInitFieldCallback Nothing cb
    mk_ParamSpecTypeInfoInstanceInitFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ParamSpecTypeInfoInstanceInitFieldCallback` into a `C_ParamSpecTypeInfoInstanceInitFieldCallback`.
wrap_ParamSpecTypeInfoInstanceInitFieldCallback ::
    Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)) ->
    ParamSpecTypeInfoInstanceInitFieldCallback ->
    C_ParamSpecTypeInfoInstanceInitFieldCallback
wrap_ParamSpecTypeInfoInstanceInitFieldCallback funptrptr _cb pspec = do
    pspec' <- B.GParamSpec.newGParamSpecFromPtr pspec
    _cb  pspec'
    maybeReleaseFunPtr funptrptr


-- callback ParamSpecTypeInfoFinalizeFieldCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoFinalizeFieldCallback =
    Ptr GParamSpec ->
    IO ()

-- Args : [Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ParamSpecTypeInfoFinalizeFieldCallback :: FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> C_ParamSpecTypeInfoFinalizeFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ParamSpecTypeInfoFinalizeFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback
    -> GParamSpec
    -> m ()
dynamic_ParamSpecTypeInfoFinalizeFieldCallback __funPtr pspec = liftIO $ do
    pspec' <- unsafeManagedPtrGetPtr pspec
    (__dynamic_C_ParamSpecTypeInfoFinalizeFieldCallback __funPtr) pspec'
    touchManagedPtr pspec
    return ()

-- | Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoFinalizeFieldCallback`.
foreign import ccall "wrapper"
    mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)

{- |
/No description available in the introspection data./
-}
type ParamSpecTypeInfoFinalizeFieldCallback =
    GParamSpec
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ParamSpecTypeInfoFinalizeFieldCallback`@.
noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback
noParamSpecTypeInfoFinalizeFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: MonadIO m => ParamSpecTypeInfoFinalizeFieldCallback -> m (GClosure C_ParamSpecTypeInfoFinalizeFieldCallback)
genClosure_ParamSpecTypeInfoFinalizeFieldCallback cb = liftIO $ do
    let cb' = wrap_ParamSpecTypeInfoFinalizeFieldCallback Nothing cb
    mk_ParamSpecTypeInfoFinalizeFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ParamSpecTypeInfoFinalizeFieldCallback` into a `C_ParamSpecTypeInfoFinalizeFieldCallback`.
wrap_ParamSpecTypeInfoFinalizeFieldCallback ::
    Maybe (Ptr (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)) ->
    ParamSpecTypeInfoFinalizeFieldCallback ->
    C_ParamSpecTypeInfoFinalizeFieldCallback
wrap_ParamSpecTypeInfoFinalizeFieldCallback funptrptr _cb pspec = do
    pspec' <- B.GParamSpec.newGParamSpecFromPtr pspec
    _cb  pspec'
    maybeReleaseFunPtr funptrptr


-- callback ObjectSetPropertyFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the numeric id under which the property was registered with\n g_object_class_install_property().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value for the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GParamSpec describing the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the @set_property function of #GObjectClass.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ObjectSetPropertyFunc =
    Ptr GObject.Object.Object ->
    Word32 ->
    Ptr GValue ->
    Ptr GParamSpec ->
    IO ()

-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the numeric id under which the property was registered with\n g_object_class_install_property().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value for the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GParamSpec describing the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ObjectSetPropertyFunc :: FunPtr C_ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ObjectSetPropertyFunc ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
    FunPtr C_ObjectSetPropertyFunc
    -> a
    {- ^ /@object@/: a 'GI.GObject.Objects.Object.Object' -}
    -> Word32
    {- ^ /@propertyId@/: the numeric id under which the property was registered with
 'GI.GObject.Structs.ObjectClass.objectClassInstallProperty'. -}
    -> GValue
    {- ^ /@value@/: the new value for the property -}
    -> GParamSpec
    {- ^ /@pspec@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' describing the property -}
    -> m ()
dynamic_ObjectSetPropertyFunc __funPtr object propertyId value pspec = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    value' <- unsafeManagedPtrGetPtr value
    pspec' <- unsafeManagedPtrGetPtr pspec
    (__dynamic_C_ObjectSetPropertyFunc __funPtr) object' propertyId value' pspec'
    touchManagedPtr object
    touchManagedPtr value
    touchManagedPtr pspec
    return ()

-- | Generate a function pointer callable from C code, from a `C_ObjectSetPropertyFunc`.
foreign import ccall "wrapper"
    mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)

{- |
The type of the /@setProperty@/ function of 'GI.GObject.Structs.ObjectClass.ObjectClass'.
-}
type ObjectSetPropertyFunc =
    GObject.Object.Object
    {- ^ /@object@/: a 'GI.GObject.Objects.Object.Object' -}
    -> Word32
    {- ^ /@propertyId@/: the numeric id under which the property was registered with
 'GI.GObject.Structs.ObjectClass.objectClassInstallProperty'. -}
    -> GValue
    {- ^ /@value@/: the new value for the property -}
    -> GParamSpec
    {- ^ /@pspec@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' describing the property -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectSetPropertyFunc`@.
noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc
noObjectSetPropertyFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ObjectSetPropertyFunc :: MonadIO m => ObjectSetPropertyFunc -> m (GClosure C_ObjectSetPropertyFunc)
genClosure_ObjectSetPropertyFunc cb = liftIO $ do
    let cb' = wrap_ObjectSetPropertyFunc Nothing cb
    mk_ObjectSetPropertyFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectSetPropertyFunc` into a `C_ObjectSetPropertyFunc`.
wrap_ObjectSetPropertyFunc ::
    Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) ->
    ObjectSetPropertyFunc ->
    C_ObjectSetPropertyFunc
wrap_ObjectSetPropertyFunc funptrptr _cb object propertyId value pspec = do
    object' <- (newObject GObject.Object.Object) object
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        pspec' <- B.GParamSpec.newGParamSpecFromPtr pspec
        _cb  object' propertyId value' pspec'
        maybeReleaseFunPtr funptrptr


-- callback ObjectGetPropertyFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the numeric id under which the property was registered with\n g_object_class_install_property().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GValue to return the property value in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GParamSpec describing the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the @get_property function of #GObjectClass.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ObjectGetPropertyFunc =
    Ptr GObject.Object.Object ->
    Word32 ->
    Ptr GValue ->
    Ptr GParamSpec ->
    IO ()

-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the numeric id under which the property was registered with\n g_object_class_install_property().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GValue to return the property value in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GParamSpec describing the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ObjectGetPropertyFunc :: FunPtr C_ObjectGetPropertyFunc -> C_ObjectGetPropertyFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ObjectGetPropertyFunc ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
    FunPtr C_ObjectGetPropertyFunc
    -> a
    {- ^ /@object@/: a 'GI.GObject.Objects.Object.Object' -}
    -> Word32
    {- ^ /@propertyId@/: the numeric id under which the property was registered with
 'GI.GObject.Structs.ObjectClass.objectClassInstallProperty'. -}
    -> GValue
    {- ^ /@value@/: a 'GI.GObject.Structs.Value.Value' to return the property value in -}
    -> GParamSpec
    {- ^ /@pspec@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' describing the property -}
    -> m ()
dynamic_ObjectGetPropertyFunc __funPtr object propertyId value pspec = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    value' <- unsafeManagedPtrGetPtr value
    pspec' <- unsafeManagedPtrGetPtr pspec
    (__dynamic_C_ObjectGetPropertyFunc __funPtr) object' propertyId value' pspec'
    touchManagedPtr object
    touchManagedPtr value
    touchManagedPtr pspec
    return ()

-- | Generate a function pointer callable from C code, from a `C_ObjectGetPropertyFunc`.
foreign import ccall "wrapper"
    mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc)

{- |
The type of the /@getProperty@/ function of 'GI.GObject.Structs.ObjectClass.ObjectClass'.
-}
type ObjectGetPropertyFunc =
    GObject.Object.Object
    {- ^ /@object@/: a 'GI.GObject.Objects.Object.Object' -}
    -> Word32
    {- ^ /@propertyId@/: the numeric id under which the property was registered with
 'GI.GObject.Structs.ObjectClass.objectClassInstallProperty'. -}
    -> GValue
    {- ^ /@value@/: a 'GI.GObject.Structs.Value.Value' to return the property value in -}
    -> GParamSpec
    {- ^ /@pspec@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' describing the property -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectGetPropertyFunc`@.
noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc
noObjectGetPropertyFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ObjectGetPropertyFunc :: MonadIO m => ObjectGetPropertyFunc -> m (GClosure C_ObjectGetPropertyFunc)
genClosure_ObjectGetPropertyFunc cb = liftIO $ do
    let cb' = wrap_ObjectGetPropertyFunc Nothing cb
    mk_ObjectGetPropertyFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectGetPropertyFunc` into a `C_ObjectGetPropertyFunc`.
wrap_ObjectGetPropertyFunc ::
    Maybe (Ptr (FunPtr C_ObjectGetPropertyFunc)) ->
    ObjectGetPropertyFunc ->
    C_ObjectGetPropertyFunc
wrap_ObjectGetPropertyFunc funptrptr _cb object propertyId value pspec = do
    object' <- (newObject GObject.Object.Object) object
    B.ManagedPtr.withTransient GValue value $ \value' -> do
        pspec' <- B.GParamSpec.newGParamSpecFromPtr pspec
        _cb  object' propertyId value' pspec'
        maybeReleaseFunPtr funptrptr


-- callback ObjectFinalizeFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GObject being finalized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of the @finalize function of #GObjectClass.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ObjectFinalizeFunc =
    Ptr GObject.Object.Object ->
    IO ()

-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GObject being finalized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ObjectFinalizeFunc :: FunPtr C_ObjectFinalizeFunc -> C_ObjectFinalizeFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ObjectFinalizeFunc ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) =>
    FunPtr C_ObjectFinalizeFunc
    -> a
    {- ^ /@object@/: the 'GI.GObject.Objects.Object.Object' being finalized -}
    -> m ()
dynamic_ObjectFinalizeFunc __funPtr object = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    (__dynamic_C_ObjectFinalizeFunc __funPtr) object'
    touchManagedPtr object
    return ()

-- | Generate a function pointer callable from C code, from a `C_ObjectFinalizeFunc`.
foreign import ccall "wrapper"
    mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)

{- |
The type of the /@finalize@/ function of 'GI.GObject.Structs.ObjectClass.ObjectClass'.
-}
type ObjectFinalizeFunc =
    GObject.Object.Object
    {- ^ /@object@/: the 'GI.GObject.Objects.Object.Object' being finalized -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectFinalizeFunc`@.
noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc
noObjectFinalizeFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ObjectFinalizeFunc :: MonadIO m => ObjectFinalizeFunc -> m (GClosure C_ObjectFinalizeFunc)
genClosure_ObjectFinalizeFunc cb = liftIO $ do
    let cb' = wrap_ObjectFinalizeFunc Nothing cb
    mk_ObjectFinalizeFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectFinalizeFunc` into a `C_ObjectFinalizeFunc`.
wrap_ObjectFinalizeFunc ::
    Maybe (Ptr (FunPtr C_ObjectFinalizeFunc)) ->
    ObjectFinalizeFunc ->
    C_ObjectFinalizeFunc
wrap_ObjectFinalizeFunc funptrptr _cb object = do
    object' <- (newObject GObject.Object.Object) object
    _cb  object'
    maybeReleaseFunPtr funptrptr


-- callback InterfaceInitFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "g_iface", argType = TInterface (Name {namespace = "GObject", name = "TypeInterface"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The interface structure to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iface_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The @interface_data supplied via the #GInterfaceInfo structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function used by the type system to initialize a new\ninterface.  This function should initialize all internal data and\nallocate any resources required by the interface.\n\nThe members of @iface_data are guaranteed to have been filled with\nzeros before this function is called.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_InterfaceInitFunc =
    Ptr GObject.TypeInterface.TypeInterface ->
    Ptr () ->
    IO ()

-- Args : [Arg {argCName = "g_iface", argType = TInterface (Name {namespace = "GObject", name = "TypeInterface"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The interface structure to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iface_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The @interface_data supplied via the #GInterfaceInfo structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InterfaceInitFunc :: FunPtr C_InterfaceInitFunc -> C_InterfaceInitFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InterfaceInitFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_InterfaceInitFunc
    -> GObject.TypeInterface.TypeInterface
    {- ^ /@gIface@/: The interface structure to initialize -}
    -> Ptr ()
    {- ^ /@ifaceData@/: The /@interfaceData@/ supplied via the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' structure -}
    -> m ()
dynamic_InterfaceInitFunc __funPtr gIface ifaceData = liftIO $ do
    gIface' <- unsafeManagedPtrGetPtr gIface
    (__dynamic_C_InterfaceInitFunc __funPtr) gIface' ifaceData
    touchManagedPtr gIface
    return ()

-- | Generate a function pointer callable from C code, from a `C_InterfaceInitFunc`.
foreign import ccall "wrapper"
    mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)

{- |
A callback function used by the type system to initialize a new
interface.  This function should initialize all internal data and
allocate any resources required by the interface.

The members of /@ifaceData@/ are guaranteed to have been filled with
zeros before this function is called.
-}
type InterfaceInitFunc =
    GObject.TypeInterface.TypeInterface
    {- ^ /@gIface@/: The interface structure to initialize -}
    -> Ptr ()
    {- ^ /@ifaceData@/: The /@interfaceData@/ supplied via the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' structure -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InterfaceInitFunc`@.
noInterfaceInitFunc :: Maybe InterfaceInitFunc
noInterfaceInitFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_InterfaceInitFunc :: MonadIO m => InterfaceInitFunc -> m (GClosure C_InterfaceInitFunc)
genClosure_InterfaceInitFunc cb = liftIO $ do
    let cb' = wrap_InterfaceInitFunc Nothing cb
    mk_InterfaceInitFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `InterfaceInitFunc` into a `C_InterfaceInitFunc`.
wrap_InterfaceInitFunc ::
    Maybe (Ptr (FunPtr C_InterfaceInitFunc)) ->
    InterfaceInitFunc ->
    C_InterfaceInitFunc
wrap_InterfaceInitFunc funptrptr _cb gIface ifaceData = do
    gIface' <- (newPtr GObject.TypeInterface.TypeInterface) gIface
    _cb  gIface' ifaceData
    maybeReleaseFunPtr funptrptr


-- callback InterfaceFinalizeFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "g_iface", argType = TInterface (Name {namespace = "GObject", name = "TypeInterface"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The interface structure to finalize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iface_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The @interface_data supplied via the #GInterfaceInfo structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function used by the type system to finalize an interface.\nThis function should destroy any internal data and release any resources\nallocated by the corresponding GInterfaceInitFunc() function.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_InterfaceFinalizeFunc =
    Ptr GObject.TypeInterface.TypeInterface ->
    Ptr () ->
    IO ()

-- Args : [Arg {argCName = "g_iface", argType = TInterface (Name {namespace = "GObject", name = "TypeInterface"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The interface structure to finalize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iface_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The @interface_data supplied via the #GInterfaceInfo structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InterfaceFinalizeFunc :: FunPtr C_InterfaceFinalizeFunc -> C_InterfaceFinalizeFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InterfaceFinalizeFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_InterfaceFinalizeFunc
    -> GObject.TypeInterface.TypeInterface
    {- ^ /@gIface@/: The interface structure to finalize -}
    -> Ptr ()
    {- ^ /@ifaceData@/: The /@interfaceData@/ supplied via the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' structure -}
    -> m ()
dynamic_InterfaceFinalizeFunc __funPtr gIface ifaceData = liftIO $ do
    gIface' <- unsafeManagedPtrGetPtr gIface
    (__dynamic_C_InterfaceFinalizeFunc __funPtr) gIface' ifaceData
    touchManagedPtr gIface
    return ()

-- | Generate a function pointer callable from C code, from a `C_InterfaceFinalizeFunc`.
foreign import ccall "wrapper"
    mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc)

{- |
A callback function used by the type system to finalize an interface.
This function should destroy any internal data and release any resources
allocated by the corresponding @/GInterfaceInitFunc()/@ function.
-}
type InterfaceFinalizeFunc =
    GObject.TypeInterface.TypeInterface
    {- ^ /@gIface@/: The interface structure to finalize -}
    -> Ptr ()
    {- ^ /@ifaceData@/: The /@interfaceData@/ supplied via the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' structure -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InterfaceFinalizeFunc`@.
noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc
noInterfaceFinalizeFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_InterfaceFinalizeFunc :: MonadIO m => InterfaceFinalizeFunc -> m (GClosure C_InterfaceFinalizeFunc)
genClosure_InterfaceFinalizeFunc cb = liftIO $ do
    let cb' = wrap_InterfaceFinalizeFunc Nothing cb
    mk_InterfaceFinalizeFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `InterfaceFinalizeFunc` into a `C_InterfaceFinalizeFunc`.
wrap_InterfaceFinalizeFunc ::
    Maybe (Ptr (FunPtr C_InterfaceFinalizeFunc)) ->
    InterfaceFinalizeFunc ->
    C_InterfaceFinalizeFunc
wrap_InterfaceFinalizeFunc funptrptr _cb gIface ifaceData = do
    gIface' <- (newPtr GObject.TypeInterface.TypeInterface) gIface
    _cb  gIface' ifaceData
    maybeReleaseFunPtr funptrptr


-- callback InstanceInitFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "instance", argType = TInterface (Name {namespace = "GObject", name = "TypeInstance"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The instance to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The class of the type the instance is\n   created for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function used by the type system to initialize a new\ninstance of a type. This function initializes all instance members and\nallocates any resources required by it.\n\nInitialization of a derived instance involves calling all its parent\ntypes instance initializers, so the class member of the instance\nis altered during its initialization to always point to the class that\nbelongs to the type the current initializer was introduced for.\n\nThe extended members of @instance are guaranteed to have been filled with\nzeros before this function is called.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_InstanceInitFunc =
    Ptr GObject.TypeInstance.TypeInstance ->
    Ptr GObject.TypeClass.TypeClass ->
    IO ()

-- Args : [Arg {argCName = "instance", argType = TInterface (Name {namespace = "GObject", name = "TypeInstance"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The instance to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The class of the type the instance is\n   created for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_InstanceInitFunc :: FunPtr C_InstanceInitFunc -> C_InstanceInitFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_InstanceInitFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_InstanceInitFunc
    -> GObject.TypeInstance.TypeInstance
    {- ^ /@instance@/: The instance to initialize -}
    -> GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The class of the type the instance is
   created for -}
    -> m ()
dynamic_InstanceInitFunc __funPtr instance_ gClass = liftIO $ do
    instance_' <- unsafeManagedPtrGetPtr instance_
    gClass' <- unsafeManagedPtrGetPtr gClass
    (__dynamic_C_InstanceInitFunc __funPtr) instance_' gClass'
    touchManagedPtr instance_
    touchManagedPtr gClass
    return ()

-- | Generate a function pointer callable from C code, from a `C_InstanceInitFunc`.
foreign import ccall "wrapper"
    mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)

{- |
A callback function used by the type system to initialize a new
instance of a type. This function initializes all instance members and
allocates any resources required by it.

Initialization of a derived instance involves calling all its parent
types instance initializers, so the class member of the instance
is altered during its initialization to always point to the class that
belongs to the type the current initializer was introduced for.

The extended members of /@instance@/ are guaranteed to have been filled with
zeros before this function is called.
-}
type InstanceInitFunc =
    GObject.TypeInstance.TypeInstance
    {- ^ /@instance@/: The instance to initialize -}
    -> GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The class of the type the instance is
   created for -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InstanceInitFunc`@.
noInstanceInitFunc :: Maybe InstanceInitFunc
noInstanceInitFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_InstanceInitFunc :: MonadIO m => InstanceInitFunc -> m (GClosure C_InstanceInitFunc)
genClosure_InstanceInitFunc cb = liftIO $ do
    let cb' = wrap_InstanceInitFunc Nothing cb
    mk_InstanceInitFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `InstanceInitFunc` into a `C_InstanceInitFunc`.
wrap_InstanceInitFunc ::
    Maybe (Ptr (FunPtr C_InstanceInitFunc)) ->
    InstanceInitFunc ->
    C_InstanceInitFunc
wrap_InstanceInitFunc funptrptr _cb instance_ gClass = do
    instance_' <- (newPtr GObject.TypeInstance.TypeInstance) instance_
    gClass' <- (newPtr GObject.TypeClass.TypeClass) gClass
    _cb  instance_' gClass'
    maybeReleaseFunPtr funptrptr


-- callback ClosureNotify
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data specified when registering the notification callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GClosure on which the notification is emitted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type used for the various notification callbacks which can be registered\non closures.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ClosureNotify =
    Ptr () ->
    Ptr (GClosure ()) ->
    IO ()

-- Args : [Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data specified when registering the notification callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GClosure on which the notification is emitted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ClosureNotify :: FunPtr C_ClosureNotify -> C_ClosureNotify

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ClosureNotify ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ClosureNotify
    -> Ptr ()
    {- ^ /@data@/: data specified when registering the notification callback -}
    -> GClosure a
    {- ^ /@closure@/: the 'GI.GObject.Structs.Closure.Closure' on which the notification is emitted -}
    -> m ()
dynamic_ClosureNotify __funPtr data_ closure = liftIO $ do
    closure' <- unsafeManagedPtrCastPtr closure
    (__dynamic_C_ClosureNotify __funPtr) data_ closure'
    touchManagedPtr closure
    return ()

-- | Generate a function pointer callable from C code, from a `C_ClosureNotify`.
foreign import ccall "wrapper"
    mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify)

{- |
The type used for the various notification callbacks which can be registered
on closures.
-}
type ClosureNotify =
    Ptr ()
    {- ^ /@data@/: data specified when registering the notification callback -}
    -> GClosure ()
    {- ^ /@closure@/: the 'GI.GObject.Structs.Closure.Closure' on which the notification is emitted -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClosureNotify`@.
noClosureNotify :: Maybe ClosureNotify
noClosureNotify = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ClosureNotify :: MonadIO m => ClosureNotify -> m (GClosure C_ClosureNotify)
genClosure_ClosureNotify cb = liftIO $ do
    let cb' = wrap_ClosureNotify Nothing cb
    mk_ClosureNotify cb' >>= B.GClosure.newGClosure


-- | Wrap a `ClosureNotify` into a `C_ClosureNotify`.
wrap_ClosureNotify ::
    Maybe (Ptr (FunPtr C_ClosureNotify)) ->
    ClosureNotify ->
    C_ClosureNotify
wrap_ClosureNotify funptrptr _cb data_ closure = do
    closure' <- (B.GClosure.newGClosureFromPtr . FP.castPtr) closure
    _cb  data_ closure'
    maybeReleaseFunPtr funptrptr


-- callback ClosureMarshalFieldCallback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_param_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "param_values", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "invocation_hint", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "marshal_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ClosureMarshalFieldCallback =
    Ptr (GClosure ()) ->
    Ptr GValue ->
    Word32 ->
    Ptr GValue ->
    Ptr () ->
    Ptr () ->
    IO ()

-- Args : [Arg {argCName = "closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_param_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "param_values", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "invocation_hint", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "marshal_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ClosureMarshalFieldCallback :: FunPtr C_ClosureMarshalFieldCallback -> C_ClosureMarshalFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ClosureMarshalFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ClosureMarshalFieldCallback
    -> GClosure a
    -> GValue
    -> Word32
    -> GValue
    -> Ptr ()
    -> Ptr ()
    -> m ()
dynamic_ClosureMarshalFieldCallback __funPtr closure returnValue nParamValues paramValues invocationHint marshalData = liftIO $ do
    closure' <- unsafeManagedPtrCastPtr closure
    returnValue' <- unsafeManagedPtrGetPtr returnValue
    paramValues' <- unsafeManagedPtrGetPtr paramValues
    (__dynamic_C_ClosureMarshalFieldCallback __funPtr) closure' returnValue' nParamValues paramValues' invocationHint marshalData
    touchManagedPtr closure
    touchManagedPtr returnValue
    touchManagedPtr paramValues
    return ()

-- | Generate a function pointer callable from C code, from a `C_ClosureMarshalFieldCallback`.
foreign import ccall "wrapper"
    mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback)

{- |
/No description available in the introspection data./
-}
type ClosureMarshalFieldCallback =
    GClosure ()
    -> GValue
    -> Word32
    -> GValue
    -> Ptr ()
    -> Ptr ()
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClosureMarshalFieldCallback`@.
noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback
noClosureMarshalFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ClosureMarshalFieldCallback :: MonadIO m => ClosureMarshalFieldCallback -> m (GClosure C_ClosureMarshalFieldCallback)
genClosure_ClosureMarshalFieldCallback cb = liftIO $ do
    let cb' = wrap_ClosureMarshalFieldCallback Nothing cb
    mk_ClosureMarshalFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ClosureMarshalFieldCallback` into a `C_ClosureMarshalFieldCallback`.
wrap_ClosureMarshalFieldCallback ::
    Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) ->
    ClosureMarshalFieldCallback ->
    C_ClosureMarshalFieldCallback
wrap_ClosureMarshalFieldCallback funptrptr _cb closure returnValue nParamValues paramValues invocationHint marshalData = do
    closure' <- (B.GClosure.newGClosureFromPtr . FP.castPtr) closure
    B.ManagedPtr.withTransient GValue returnValue $ \returnValue' -> do
        B.ManagedPtr.withTransient GValue paramValues $ \paramValues' -> do
            _cb  closure' returnValue' nParamValues paramValues' invocationHint marshalData
            maybeReleaseFunPtr funptrptr


-- callback ClassInitFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure to initialize.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "class_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The @class_data member supplied via the #GTypeInfo structure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function used by the type system to initialize the class\nof a specific type. This function should initialize all static class\nmembers.\n\nThe initialization process of a class involves:\n\n- Copying common members from the parent class over to the\n  derived class structure.\n- Zero initialization of the remaining members not copied\n  over from the parent class.\n- Invocation of the GBaseInitFunc() initializers of all parent\n  types and the class' type.\n- Invocation of the class' GClassInitFunc() initializer.\n\nSince derived classes are partially initialized through a memory copy\nof the parent class, the general rule is that GBaseInitFunc() and\nGBaseFinalizeFunc() should take care of necessary reinitialization\nand release of those class members that were introduced by the type\nthat specified these GBaseInitFunc()/GBaseFinalizeFunc().\nGClassInitFunc() should only care about initializing static\nclass members, while dynamic class members (such as allocated strings\nor reference counted resources) are better handled by a GBaseInitFunc()\nfor this type, so proper initialization of the dynamic class members\nis performed for class initialization of derived types as well.\n\nAn example may help to correspond the intend of the different class\ninitializers:\n\n|[<!-- language=\"C\" -->\ntypedef struct {\n  GObjectClass parent_class;\n  gint         static_integer;\n  gchar       *dynamic_string;\n} TypeAClass;\nstatic void\ntype_a_base_class_init (TypeAClass *class)\n{\n  class->dynamic_string = g_strdup (\"some string\");\n}\nstatic void\ntype_a_base_class_finalize (TypeAClass *class)\n{\n  g_free (class->dynamic_string);\n}\nstatic void\ntype_a_class_init (TypeAClass *class)\n{\n  class->static_integer = 42;\n}\n\ntypedef struct {\n  TypeAClass   parent_class;\n  gfloat       static_float;\n  GString     *dynamic_gstring;\n} TypeBClass;\nstatic void\ntype_b_base_class_init (TypeBClass *class)\n{\n  class->dynamic_gstring = g_string_new (\"some other string\");\n}\nstatic void\ntype_b_base_class_finalize (TypeBClass *class)\n{\n  g_string_free (class->dynamic_gstring);\n}\nstatic void\ntype_b_class_init (TypeBClass *class)\n{\n  class->static_float = 3.14159265358979323846;\n}\n]|\nInitialization of TypeBClass will first cause initialization of\nTypeAClass (derived classes reference their parent classes, see\ng_type_class_ref() on this).\n\nInitialization of TypeAClass roughly involves zero-initializing its fields,\nthen calling its GBaseInitFunc() type_a_base_class_init() to allocate\nits dynamic members (dynamic_string), and finally calling its GClassInitFunc()\ntype_a_class_init() to initialize its static members (static_integer).\nThe first step in the initialization process of TypeBClass is then\na plain memory copy of the contents of TypeAClass into TypeBClass and\nzero-initialization of the remaining fields in TypeBClass.\nThe dynamic members of TypeAClass within TypeBClass now need\nreinitialization which is performed by calling type_a_base_class_init()\nwith an argument of TypeBClass.\n\nAfter that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init()\nis called to allocate the dynamic members of TypeBClass (dynamic_gstring),\nand finally the GClassInitFunc() of TypeBClass, type_b_class_init(),\nis called to complete the initialization process with the static members\n(static_float).\n\nCorresponding finalization counter parts to the GBaseInitFunc() functions\nhave to be provided to release allocated resources at class finalization\ntime.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ClassInitFunc =
    Ptr GObject.TypeClass.TypeClass ->
    Ptr () ->
    IO ()

-- Args : [Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure to initialize.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "class_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The @class_data member supplied via the #GTypeInfo structure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ClassInitFunc :: FunPtr C_ClassInitFunc -> C_ClassInitFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ClassInitFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ClassInitFunc
    -> GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize. -}
    -> Ptr ()
    {- ^ /@classData@/: The /@classData@/ member supplied via the 'GI.GObject.Structs.TypeInfo.TypeInfo' structure. -}
    -> m ()
dynamic_ClassInitFunc __funPtr gClass classData = liftIO $ do
    gClass' <- unsafeManagedPtrGetPtr gClass
    (__dynamic_C_ClassInitFunc __funPtr) gClass' classData
    touchManagedPtr gClass
    return ()

-- | Generate a function pointer callable from C code, from a `C_ClassInitFunc`.
foreign import ccall "wrapper"
    mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)

{- |
A callback function used by the type system to initialize the class
of a specific type. This function should initialize all static class
members.

The initialization process of a class involves:

* Copying common members from the parent class over to the
derived class structure.
* Zero initialization of the remaining members not copied
over from the parent class.
* Invocation of the @/GBaseInitFunc()/@ initializers of all parent
types and the class\' type.
* Invocation of the class\' @/GClassInitFunc()/@ initializer.


Since derived classes are partially initialized through a memory copy
of the parent class, the general rule is that @/GBaseInitFunc()/@ and
@/GBaseFinalizeFunc()/@ should take care of necessary reinitialization
and release of those class members that were introduced by the type
that specified these @/GBaseInitFunc()/@\/@/GBaseFinalizeFunc()/@.
@/GClassInitFunc()/@ should only care about initializing static
class members, while dynamic class members (such as allocated strings
or reference counted resources) are better handled by a @/GBaseInitFunc()/@
for this type, so proper initialization of the dynamic class members
is performed for class initialization of derived types as well.

An example may help to correspond the intend of the different class
initializers:


=== /C code/
>
>typedef struct {
>  GObjectClass parent_class;
>  gint         static_integer;
>  gchar       *dynamic_string;
>} TypeAClass;
>static void
>type_a_base_class_init (TypeAClass *class)
>{
>  class->dynamic_string = g_strdup ("some string");
>}
>static void
>type_a_base_class_finalize (TypeAClass *class)
>{
>  g_free (class->dynamic_string);
>}
>static void
>type_a_class_init (TypeAClass *class)
>{
>  class->static_integer = 42;
>}
>
>typedef struct {
>  TypeAClass   parent_class;
>  gfloat       static_float;
>  GString     *dynamic_gstring;
>} TypeBClass;
>static void
>type_b_base_class_init (TypeBClass *class)
>{
>  class->dynamic_gstring = g_string_new ("some other string");
>}
>static void
>type_b_base_class_finalize (TypeBClass *class)
>{
>  g_string_free (class->dynamic_gstring);
>}
>static void
>type_b_class_init (TypeBClass *class)
>{
>  class->static_float = 3.14159265358979323846;
>}

Initialization of TypeBClass will first cause initialization of
TypeAClass (derived classes reference their parent classes, see
'GI.GObject.Functions.typeClassRef' on this).

Initialization of TypeAClass roughly involves zero-initializing its fields,
then calling its @/GBaseInitFunc()/@ @/type_a_base_class_init()/@ to allocate
its dynamic members (dynamic_string), and finally calling its @/GClassInitFunc()/@
@/type_a_class_init()/@ to initialize its static members (static_integer).
The first step in the initialization process of TypeBClass is then
a plain memory copy of the contents of TypeAClass into TypeBClass and
zero-initialization of the remaining fields in TypeBClass.
The dynamic members of TypeAClass within TypeBClass now need
reinitialization which is performed by calling @/type_a_base_class_init()/@
with an argument of TypeBClass.

After that, the @/GBaseInitFunc()/@ of TypeBClass, @/type_b_base_class_init()/@
is called to allocate the dynamic members of TypeBClass (dynamic_gstring),
and finally the @/GClassInitFunc()/@ of TypeBClass, @/type_b_class_init()/@,
is called to complete the initialization process with the static members
(static_float).

Corresponding finalization counter parts to the @/GBaseInitFunc()/@ functions
have to be provided to release allocated resources at class finalization
time.
-}
type ClassInitFunc =
    GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize. -}
    -> Ptr ()
    {- ^ /@classData@/: The /@classData@/ member supplied via the 'GI.GObject.Structs.TypeInfo.TypeInfo' structure. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassInitFunc`@.
noClassInitFunc :: Maybe ClassInitFunc
noClassInitFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ClassInitFunc :: MonadIO m => ClassInitFunc -> m (GClosure C_ClassInitFunc)
genClosure_ClassInitFunc cb = liftIO $ do
    let cb' = wrap_ClassInitFunc Nothing cb
    mk_ClassInitFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `ClassInitFunc` into a `C_ClassInitFunc`.
wrap_ClassInitFunc ::
    Maybe (Ptr (FunPtr C_ClassInitFunc)) ->
    ClassInitFunc ->
    C_ClassInitFunc
wrap_ClassInitFunc funptrptr _cb gClass classData = do
    gClass' <- (newPtr GObject.TypeClass.TypeClass) gClass
    _cb  gClass' classData
    maybeReleaseFunPtr funptrptr


-- callback ClassFinalizeFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure to finalize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "class_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The @class_data member supplied via the #GTypeInfo structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function used by the type system to finalize a class.\nThis function is rarely needed, as dynamically allocated class resources\nshould be handled by GBaseInitFunc() and GBaseFinalizeFunc().\nAlso, specification of a GClassFinalizeFunc() in the #GTypeInfo\nstructure of a static type is invalid, because classes of static types\nwill never be finalized (they are artificially kept alive when their\nreference count drops to zero).", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_ClassFinalizeFunc =
    Ptr GObject.TypeClass.TypeClass ->
    Ptr () ->
    IO ()

-- Args : [Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure to finalize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "class_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The @class_data member supplied via the #GTypeInfo structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ClassFinalizeFunc :: FunPtr C_ClassFinalizeFunc -> C_ClassFinalizeFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ClassFinalizeFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_ClassFinalizeFunc
    -> GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize -}
    -> Ptr ()
    {- ^ /@classData@/: The /@classData@/ member supplied via the 'GI.GObject.Structs.TypeInfo.TypeInfo' structure -}
    -> m ()
dynamic_ClassFinalizeFunc __funPtr gClass classData = liftIO $ do
    gClass' <- unsafeManagedPtrGetPtr gClass
    (__dynamic_C_ClassFinalizeFunc __funPtr) gClass' classData
    touchManagedPtr gClass
    return ()

-- | Generate a function pointer callable from C code, from a `C_ClassFinalizeFunc`.
foreign import ccall "wrapper"
    mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc)

{- |
A callback function used by the type system to finalize a class.
This function is rarely needed, as dynamically allocated class resources
should be handled by @/GBaseInitFunc()/@ and @/GBaseFinalizeFunc()/@.
Also, specification of a @/GClassFinalizeFunc()/@ in the 'GI.GObject.Structs.TypeInfo.TypeInfo'
structure of a static type is invalid, because classes of static types
will never be finalized (they are artificially kept alive when their
reference count drops to zero).
-}
type ClassFinalizeFunc =
    GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize -}
    -> Ptr ()
    {- ^ /@classData@/: The /@classData@/ member supplied via the 'GI.GObject.Structs.TypeInfo.TypeInfo' structure -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassFinalizeFunc`@.
noClassFinalizeFunc :: Maybe ClassFinalizeFunc
noClassFinalizeFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ClassFinalizeFunc :: MonadIO m => ClassFinalizeFunc -> m (GClosure C_ClassFinalizeFunc)
genClosure_ClassFinalizeFunc cb = liftIO $ do
    let cb' = wrap_ClassFinalizeFunc Nothing cb
    mk_ClassFinalizeFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `ClassFinalizeFunc` into a `C_ClassFinalizeFunc`.
wrap_ClassFinalizeFunc ::
    Maybe (Ptr (FunPtr C_ClassFinalizeFunc)) ->
    ClassFinalizeFunc ->
    C_ClassFinalizeFunc
wrap_ClassFinalizeFunc funptrptr _cb gClass classData = do
    gClass' <- (newPtr GObject.TypeClass.TypeClass) gClass
    _cb  gClass' classData
    maybeReleaseFunPtr funptrptr


-- callback Callback
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type used for callback functions in structure definitions and function\nsignatures. This doesn't mean that all callback functions must take no\nparameters and return void. The required signature of a callback function\nis determined by the context in which is used (e.g. the signal to which it\nis connected). Use G_CALLBACK() to cast the callback function to a #GCallback.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_Callback =
    IO ()

-- Args : []
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_Callback :: FunPtr C_Callback -> C_Callback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_Callback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_Callback
    -> m ()
dynamic_Callback __funPtr = liftIO $ do
    (__dynamic_C_Callback __funPtr)
    return ()

-- | Generate a function pointer callable from C code, from a `C_Callback`.
foreign import ccall "wrapper"
    mk_Callback :: C_Callback -> IO (FunPtr C_Callback)

{- |
The type used for callback functions in structure definitions and function
signatures. This doesn\'t mean that all callback functions must take no
parameters and return void. The required signature of a callback function
is determined by the context in which is used (e.g. the signal to which it
is connected). Use @/G_CALLBACK()/@ to cast the callback function to a 'GI.GObject.Callbacks.Callback'.
-}
type Callback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `Callback`@.
noCallback :: Maybe Callback
noCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)
genClosure_Callback cb = liftIO $ do
    let cb' = wrap_Callback Nothing cb
    mk_Callback cb' >>= B.GClosure.newGClosure


-- | Wrap a `Callback` into a `C_Callback`.
wrap_Callback ::
    Maybe (Ptr (FunPtr C_Callback)) ->
    Callback ->
    C_Callback
wrap_Callback funptrptr _cb = do
    _cb
    maybeReleaseFunPtr funptrptr


-- callback BoxedFreeFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "boxed", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The boxed structure to be freed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "This function is provided by the user and should free the boxed\nstructure passed.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_BoxedFreeFunc =
    Ptr () ->
    IO ()

-- Args : [Arg {argCName = "boxed", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The boxed structure to be freed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BoxedFreeFunc :: FunPtr C_BoxedFreeFunc -> C_BoxedFreeFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BoxedFreeFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_BoxedFreeFunc
    -> Ptr ()
    {- ^ /@boxed@/: The boxed structure to be freed. -}
    -> m ()
dynamic_BoxedFreeFunc __funPtr boxed = liftIO $ do
    (__dynamic_C_BoxedFreeFunc __funPtr) boxed
    return ()

-- | Generate a function pointer callable from C code, from a `C_BoxedFreeFunc`.
foreign import ccall "wrapper"
    mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)

{- |
This function is provided by the user and should free the boxed
structure passed.
-}
type BoxedFreeFunc =
    Ptr ()
    {- ^ /@boxed@/: The boxed structure to be freed. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BoxedFreeFunc`@.
noBoxedFreeFunc :: Maybe BoxedFreeFunc
noBoxedFreeFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_BoxedFreeFunc :: MonadIO m => BoxedFreeFunc -> m (GClosure C_BoxedFreeFunc)
genClosure_BoxedFreeFunc cb = liftIO $ do
    let cb' = wrap_BoxedFreeFunc Nothing cb
    mk_BoxedFreeFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `BoxedFreeFunc` into a `C_BoxedFreeFunc`.
wrap_BoxedFreeFunc ::
    Maybe (Ptr (FunPtr C_BoxedFreeFunc)) ->
    BoxedFreeFunc ->
    C_BoxedFreeFunc
wrap_BoxedFreeFunc funptrptr _cb boxed = do
    _cb  boxed
    maybeReleaseFunPtr funptrptr


-- callback BoxedCopyFunc
--          -> Callable {returnType = Just (TBasicType TPtr), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "The newly created copy of the boxed structure.", sinceVersion = Nothing}, args = [Arg {argCName = "boxed", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The boxed structure to be copied.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "This function is provided by the user and should produce a copy\nof the passed in boxed structure.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_BoxedCopyFunc =
    Ptr () ->
    IO (Ptr ())

-- Args : [Arg {argCName = "boxed", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The boxed structure to be copied.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BoxedCopyFunc :: FunPtr C_BoxedCopyFunc -> C_BoxedCopyFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BoxedCopyFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_BoxedCopyFunc
    -> Ptr ()
    {- ^ /@boxed@/: The boxed structure to be copied. -}
    -> m (Ptr ())
    {- ^ __Returns:__ The newly created copy of the boxed structure. -}
dynamic_BoxedCopyFunc __funPtr boxed = liftIO $ do
    result <- (__dynamic_C_BoxedCopyFunc __funPtr) boxed
    return result

-- | Generate a function pointer callable from C code, from a `C_BoxedCopyFunc`.
foreign import ccall "wrapper"
    mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc)

{- |
This function is provided by the user and should produce a copy
of the passed in boxed structure.
-}
type BoxedCopyFunc =
    Ptr ()
    {- ^ /@boxed@/: The boxed structure to be copied. -}
    -> IO (Ptr ())
    {- ^ __Returns:__ The newly created copy of the boxed structure. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `BoxedCopyFunc`@.
noBoxedCopyFunc :: Maybe BoxedCopyFunc
noBoxedCopyFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_BoxedCopyFunc :: MonadIO m => BoxedCopyFunc -> m (GClosure C_BoxedCopyFunc)
genClosure_BoxedCopyFunc cb = liftIO $ do
    let cb' = wrap_BoxedCopyFunc Nothing cb
    mk_BoxedCopyFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `BoxedCopyFunc` into a `C_BoxedCopyFunc`.
wrap_BoxedCopyFunc ::
    Maybe (Ptr (FunPtr C_BoxedCopyFunc)) ->
    BoxedCopyFunc ->
    C_BoxedCopyFunc
wrap_BoxedCopyFunc funptrptr _cb boxed = do
    result <- _cb  boxed
    maybeReleaseFunPtr funptrptr
    return result


-- callback BindingTransformFunc
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if the transformation was successful, and %FALSE\n  otherwise", sinceVersion = Nothing}, args = [Arg {argCName = "binding", argType = TInterface (Name {namespace = "GObject", name = "Binding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GBinding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GValue containing the value to transform", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GValue in which to store the transformed value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data passed to the transform function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A function to be called to transform @from_value to @to_value. If\nthis is the @transform_to function of a binding, then @from_value\nis the @source_property on the @source object, and @to_value is the\n@target_property on the @target object. If this is the\n@transform_from function of a %G_BINDING_BIDIRECTIONAL binding,\nthen those roles are reversed.", sinceVersion = Just "2.26"}}
-- | Type for the callback on the (unwrapped) C side.
type C_BindingTransformFunc =
    Ptr GObject.Binding.Binding ->
    Ptr GValue ->
    Ptr GValue ->
    Ptr () ->
    IO CInt

-- Args : [Arg {argCName = "binding", argType = TInterface (Name {namespace = "GObject", name = "Binding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GBinding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GValue containing the value to transform", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GValue in which to store the transformed value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data passed to the transform function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BindingTransformFunc :: FunPtr C_BindingTransformFunc -> C_BindingTransformFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BindingTransformFunc ::
    (B.CallStack.HasCallStack, MonadIO m, GObject.Binding.IsBinding a) =>
    FunPtr C_BindingTransformFunc
    -> a
    {- ^ /@binding@/: a 'GI.GObject.Objects.Binding.Binding' -}
    -> GValue
    {- ^ /@fromValue@/: the 'GI.GObject.Structs.Value.Value' containing the value to transform -}
    -> GValue
    {- ^ /@toValue@/: the 'GI.GObject.Structs.Value.Value' in which to store the transformed value -}
    -> Ptr ()
    {- ^ /@userData@/: data passed to the transform function -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the transformation was successful, and 'False'
  otherwise -}
dynamic_BindingTransformFunc __funPtr binding fromValue toValue userData = liftIO $ do
    binding' <- unsafeManagedPtrCastPtr binding
    fromValue' <- unsafeManagedPtrGetPtr fromValue
    toValue' <- unsafeManagedPtrGetPtr toValue
    result <- (__dynamic_C_BindingTransformFunc __funPtr) binding' fromValue' toValue' userData
    let result' = (/= 0) result
    touchManagedPtr binding
    touchManagedPtr fromValue
    touchManagedPtr toValue
    return result'

-- | Generate a function pointer callable from C code, from a `C_BindingTransformFunc`.
foreign import ccall "wrapper"
    mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)

{- |
A function to be called to transform /@fromValue@/ to /@toValue@/. If
this is the /@transformTo@/ function of a binding, then /@fromValue@/
is the /@sourceProperty@/ on the /@source@/ object, and /@toValue@/ is the
/@targetProperty@/ on the /@target@/ object. If this is the
/@transformFrom@/ function of a 'GI.GObject.Flags.BindingFlagsBidirectional' binding,
then those roles are reversed.

/Since: 2.26/
-}
type BindingTransformFunc =
    GObject.Binding.Binding
    {- ^ /@binding@/: a 'GI.GObject.Objects.Binding.Binding' -}
    -> GValue
    {- ^ /@fromValue@/: the 'GI.GObject.Structs.Value.Value' containing the value to transform -}
    -> GValue
    {- ^ /@toValue@/: the 'GI.GObject.Structs.Value.Value' in which to store the transformed value -}
    -> IO Bool
    {- ^ __Returns:__ 'True' if the transformation was successful, and 'False'
  otherwise -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `BindingTransformFunc`@.
noBindingTransformFunc :: Maybe BindingTransformFunc
noBindingTransformFunc = Nothing

{- |
A function to be called to transform /@fromValue@/ to /@toValue@/. If
this is the /@transformTo@/ function of a binding, then /@fromValue@/
is the /@sourceProperty@/ on the /@source@/ object, and /@toValue@/ is the
/@targetProperty@/ on the /@target@/ object. If this is the
/@transformFrom@/ function of a 'GI.GObject.Flags.BindingFlagsBidirectional' binding,
then those roles are reversed.

/Since: 2.26/
-}
type BindingTransformFunc_WithClosures =
    GObject.Binding.Binding
    {- ^ /@binding@/: a 'GI.GObject.Objects.Binding.Binding' -}
    -> GValue
    {- ^ /@fromValue@/: the 'GI.GObject.Structs.Value.Value' containing the value to transform -}
    -> GValue
    {- ^ /@toValue@/: the 'GI.GObject.Structs.Value.Value' in which to store the transformed value -}
    -> Ptr ()
    {- ^ /@userData@/: data passed to the transform function -}
    -> IO Bool
    {- ^ __Returns:__ 'True' if the transformation was successful, and 'False'
  otherwise -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `BindingTransformFunc_WithClosures`@.
noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures
noBindingTransformFunc_WithClosures = Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures
drop_closures_BindingTransformFunc _f binding fromValue toValue _ = _f binding fromValue toValue

-- | Wrap the callback into a `GClosure`.
genClosure_BindingTransformFunc :: MonadIO m => BindingTransformFunc -> m (GClosure C_BindingTransformFunc)
genClosure_BindingTransformFunc cb = liftIO $ do
    let cb' = drop_closures_BindingTransformFunc cb
    let cb'' = wrap_BindingTransformFunc Nothing cb'
    mk_BindingTransformFunc cb'' >>= B.GClosure.newGClosure


-- | Wrap a `BindingTransformFunc` into a `C_BindingTransformFunc`.
wrap_BindingTransformFunc ::
    Maybe (Ptr (FunPtr C_BindingTransformFunc)) ->
    BindingTransformFunc_WithClosures ->
    C_BindingTransformFunc
wrap_BindingTransformFunc funptrptr _cb binding fromValue toValue userData = do
    binding' <- (newObject GObject.Binding.Binding) binding
    B.ManagedPtr.withTransient GValue fromValue $ \fromValue' -> do
        B.ManagedPtr.withTransient GValue toValue $ \toValue' -> do
            result <- _cb  binding' fromValue' toValue' userData
            maybeReleaseFunPtr funptrptr
            let result' = (fromIntegral . fromEnum) result
            return result'


-- callback BaseInitFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function used by the type system to do base initialization\nof the class structures of derived types. It is called as part of the\ninitialization process of all derived classes and should reallocate\nor reset all dynamic class members copied over from the parent class.\nFor example, class members (such as strings) that are not sufficiently\nhandled by a plain memory copy of the parent class into the derived class\nhave to be altered. See GClassInitFunc() for a discussion of the class\ninitialization process.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_BaseInitFunc =
    Ptr GObject.TypeClass.TypeClass ->
    IO ()

-- Args : [Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure to initialize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BaseInitFunc :: FunPtr C_BaseInitFunc -> C_BaseInitFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BaseInitFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_BaseInitFunc
    -> GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize -}
    -> m ()
dynamic_BaseInitFunc __funPtr gClass = liftIO $ do
    gClass' <- unsafeManagedPtrGetPtr gClass
    (__dynamic_C_BaseInitFunc __funPtr) gClass'
    touchManagedPtr gClass
    return ()

-- | Generate a function pointer callable from C code, from a `C_BaseInitFunc`.
foreign import ccall "wrapper"
    mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)

{- |
A callback function used by the type system to do base initialization
of the class structures of derived types. It is called as part of the
initialization process of all derived classes and should reallocate
or reset all dynamic class members copied over from the parent class.
For example, class members (such as strings) that are not sufficiently
handled by a plain memory copy of the parent class into the derived class
have to be altered. See @/GClassInitFunc()/@ for a discussion of the class
initialization process.
-}
type BaseInitFunc =
    GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BaseInitFunc`@.
noBaseInitFunc :: Maybe BaseInitFunc
noBaseInitFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_BaseInitFunc :: MonadIO m => BaseInitFunc -> m (GClosure C_BaseInitFunc)
genClosure_BaseInitFunc cb = liftIO $ do
    let cb' = wrap_BaseInitFunc Nothing cb
    mk_BaseInitFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `BaseInitFunc` into a `C_BaseInitFunc`.
wrap_BaseInitFunc ::
    Maybe (Ptr (FunPtr C_BaseInitFunc)) ->
    BaseInitFunc ->
    C_BaseInitFunc
wrap_BaseInitFunc funptrptr _cb gClass = do
    gClass' <- (newPtr GObject.TypeClass.TypeClass) gClass
    _cb  gClass'
    maybeReleaseFunPtr funptrptr


-- callback BaseFinalizeFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure to finalize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A callback function used by the type system to finalize those portions\nof a derived types class structure that were setup from the corresponding\nGBaseInitFunc() function. Class finalization basically works the inverse\nway in which class initialization is performed.\nSee GClassInitFunc() for a discussion of the class initialization process.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_BaseFinalizeFunc =
    Ptr GObject.TypeClass.TypeClass ->
    IO ()

-- Args : [Arg {argCName = "g_class", argType = TInterface (Name {namespace = "GObject", name = "TypeClass"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GTypeClass structure to finalize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_BaseFinalizeFunc :: FunPtr C_BaseFinalizeFunc -> C_BaseFinalizeFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BaseFinalizeFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_BaseFinalizeFunc
    -> GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize -}
    -> m ()
dynamic_BaseFinalizeFunc __funPtr gClass = liftIO $ do
    gClass' <- unsafeManagedPtrGetPtr gClass
    (__dynamic_C_BaseFinalizeFunc __funPtr) gClass'
    touchManagedPtr gClass
    return ()

-- | Generate a function pointer callable from C code, from a `C_BaseFinalizeFunc`.
foreign import ccall "wrapper"
    mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc)

{- |
A callback function used by the type system to finalize those portions
of a derived types class structure that were setup from the corresponding
@/GBaseInitFunc()/@ function. Class finalization basically works the inverse
way in which class initialization is performed.
See @/GClassInitFunc()/@ for a discussion of the class initialization process.
-}
type BaseFinalizeFunc =
    GObject.TypeClass.TypeClass
    {- ^ /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BaseFinalizeFunc`@.
noBaseFinalizeFunc :: Maybe BaseFinalizeFunc
noBaseFinalizeFunc = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_BaseFinalizeFunc :: MonadIO m => BaseFinalizeFunc -> m (GClosure C_BaseFinalizeFunc)
genClosure_BaseFinalizeFunc cb = liftIO $ do
    let cb' = wrap_BaseFinalizeFunc Nothing cb
    mk_BaseFinalizeFunc cb' >>= B.GClosure.newGClosure


-- | Wrap a `BaseFinalizeFunc` into a `C_BaseFinalizeFunc`.
wrap_BaseFinalizeFunc ::
    Maybe (Ptr (FunPtr C_BaseFinalizeFunc)) ->
    BaseFinalizeFunc ->
    C_BaseFinalizeFunc
wrap_BaseFinalizeFunc funptrptr _cb gClass = do
    gClass' <- (newPtr GObject.TypeClass.TypeClass) gClass
    _cb  gClass'
    maybeReleaseFunPtr funptrptr