gi-gobject-2.0.31: GObject bindings

Copyright | Will Thompson and Iñaki García Etxebarria
License | LGPL-2.1
Maintainer | Iñaki García Etxebarria
Safe Haskell | None
Language | Haskell2010

GI.GObject.Callbacks

Contents

- Signals
  - BaseFinalizeFunc
  - BaseInitFunc
  - BindingTransformFunc
  - BoxedCopyFunc
  - BoxedFreeFunc
  - Callback
  - ClassFinalizeFunc
  - ClassInitFunc
  - ClosureMarshal
  - ClosureMarshalFieldCallback
  - ClosureNotify
  - InitiallyUnownedClassConstructedFieldCallback
  - InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
  - InitiallyUnownedClassDisposeFieldCallback
  - InitiallyUnownedClassFinalizeFieldCallback
  - InitiallyUnownedClassGetPropertyFieldCallback
  - InitiallyUnownedClassNotifyFieldCallback
  - InitiallyUnownedClassSetPropertyFieldCallback
  - InstanceInitFunc
  - InterfaceFinalizeFunc
  - InterfaceInitFunc
  - ObjectClassConstructedFieldCallback
  - ObjectClassDispatchPropertiesChangedFieldCallback
  - ObjectClassDisposeFieldCallback
  - ObjectClassFinalizeFieldCallback
  - ObjectClassGetPropertyFieldCallback
  - ObjectClassNotifyFieldCallback
  - ObjectClassSetPropertyFieldCallback
  - ObjectFinalizeFunc
  - ObjectGetPropertyFunc
  - ObjectSetPropertyFunc
  - ParamSpecTypeInfoFinalizeFieldCallback
  - ParamSpecTypeInfoInstanceInitFieldCallback
  - ParamSpecTypeInfoValueSetDefaultFieldCallback
  - ParamSpecTypeInfoValueValidateFieldCallback
  - ParamSpecTypeInfoValuesCmpFieldCallback
  - SignalAccumulator
  - SignalEmissionHook
  - ToggleNotify
  - TypeClassCacheFunc
  - TypeInterfaceCheckFunc
  - TypePluginCompleteInterfaceInfo
  - TypePluginCompleteTypeInfo
  - TypePluginUnuse
  - TypePluginUse
  - TypeValueCollectFunc
  - TypeValueCopyFunc
  - TypeValueFreeFunc
  - TypeValueInitFunc
  - TypeValueLCopyFunc
  - TypeValuePeekPointerFunc
  - ValueTransform
  - WeakNotify

Description

Synopsis

- type BaseFinalizeFunc = TypeClass -> IO ()
- type C_BaseFinalizeFunc = Ptr TypeClass -> IO ()
- dynamic_BaseFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_BaseFinalizeFunc -> TypeClass -> m ()
- genClosure_BaseFinalizeFunc :: MonadIO m => BaseFinalizeFunc -> m (GClosure C_BaseFinalizeFunc)
- mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc)
- noBaseFinalizeFunc :: Maybe BaseFinalizeFunc
- wrap_BaseFinalizeFunc :: Maybe (Ptr (FunPtr C_BaseFinalizeFunc)) -> BaseFinalizeFunc -> C_BaseFinalizeFunc
- type BaseInitFunc = TypeClass -> IO ()
- type C_BaseInitFunc = Ptr TypeClass -> IO ()
- dynamic_BaseInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_BaseInitFunc -> TypeClass -> m ()
- genClosure_BaseInitFunc :: MonadIO m => BaseInitFunc -> m (GClosure C_BaseInitFunc)
- mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)
- noBaseInitFunc :: Maybe BaseInitFunc
- wrap_BaseInitFunc :: Maybe (Ptr (FunPtr C_BaseInitFunc)) -> BaseInitFunc -> C_BaseInitFunc
- type BindingTransformFunc = Binding -> GValue -> GValue -> IO Bool
- type BindingTransformFunc_WithClosures = Binding -> GValue -> GValue -> Ptr () -> IO Bool
- type C_BindingTransformFunc = Ptr Binding -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt
- drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures
- dynamic_BindingTransformFunc :: (HasCallStack, MonadIO m, IsBinding a) => FunPtr C_BindingTransformFunc -> a -> GValue -> GValue -> Ptr () -> m Bool
- genClosure_BindingTransformFunc :: MonadIO m => BindingTransformFunc -> m (GClosure C_BindingTransformFunc)
- mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)
- noBindingTransformFunc :: Maybe BindingTransformFunc
- noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures
- wrap_BindingTransformFunc :: Maybe (Ptr (FunPtr C_BindingTransformFunc)) -> BindingTransformFunc_WithClosures -> C_BindingTransformFunc
- type BoxedCopyFunc = Ptr () -> IO (Ptr ())
- type C_BoxedCopyFunc = Ptr () -> IO (Ptr ())
- dynamic_BoxedCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_BoxedCopyFunc -> Ptr () -> m (Ptr ())
- genClosure_BoxedCopyFunc :: MonadIO m => BoxedCopyFunc -> m (GClosure C_BoxedCopyFunc)
- mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc)
- noBoxedCopyFunc :: Maybe BoxedCopyFunc
- wrap_BoxedCopyFunc :: Maybe (Ptr (FunPtr C_BoxedCopyFunc)) -> BoxedCopyFunc -> C_BoxedCopyFunc
- type BoxedFreeFunc = Ptr () -> IO ()
- type C_BoxedFreeFunc = Ptr () -> IO ()
- dynamic_BoxedFreeFunc :: (HasCallStack, MonadIO m) => FunPtr C_BoxedFreeFunc -> Ptr () -> m ()
- genClosure_BoxedFreeFunc :: MonadIO m => BoxedFreeFunc -> m (GClosure C_BoxedFreeFunc)
- mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)
- noBoxedFreeFunc :: Maybe BoxedFreeFunc
- wrap_BoxedFreeFunc :: Maybe (Ptr (FunPtr C_BoxedFreeFunc)) -> BoxedFreeFunc -> C_BoxedFreeFunc
- type C_Callback = IO ()
- type Callback = IO ()
- dynamic_Callback :: (HasCallStack, MonadIO m) => FunPtr C_Callback -> m ()
- genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)
- mk_Callback :: C_Callback -> IO (FunPtr C_Callback)
- noCallback :: Maybe Callback
- wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback -> C_Callback
- type C_ClassFinalizeFunc = Ptr TypeClass -> Ptr () -> IO ()
- type ClassFinalizeFunc = TypeClass -> Ptr () -> IO ()
- dynamic_ClassFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_ClassFinalizeFunc -> TypeClass -> Ptr () -> m ()
- genClosure_ClassFinalizeFunc :: MonadIO m => ClassFinalizeFunc -> m (GClosure C_ClassFinalizeFunc)
- mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc)
- noClassFinalizeFunc :: Maybe ClassFinalizeFunc
- wrap_ClassFinalizeFunc :: Maybe (Ptr (FunPtr C_ClassFinalizeFunc)) -> ClassFinalizeFunc -> C_ClassFinalizeFunc
- type C_ClassInitFunc = Ptr TypeClass -> Ptr () -> IO ()
- type ClassInitFunc = TypeClass -> Ptr () -> IO ()
- dynamic_ClassInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_ClassInitFunc -> TypeClass -> Ptr () -> m ()
- genClosure_ClassInitFunc :: MonadIO m => ClassInitFunc -> m (GClosure C_ClassInitFunc)
- mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)
- noClassInitFunc :: Maybe ClassInitFunc
- wrap_ClassInitFunc :: Maybe (Ptr (FunPtr C_ClassInitFunc)) -> ClassInitFunc -> C_ClassInitFunc
- type C_ClosureMarshal = Ptr (GClosure ()) -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()
- type ClosureMarshal = GClosure () -> Maybe GValue -> [GValue] -> Ptr () -> Ptr () -> IO ()
- dynamic_ClosureMarshal :: (HasCallStack, MonadIO m) => FunPtr C_ClosureMarshal -> GClosure a -> Maybe GValue -> [GValue] -> Ptr () -> Ptr () -> m ()
- genClosure_ClosureMarshal :: MonadIO m => ClosureMarshal -> m (GClosure C_ClosureMarshal)
- mk_ClosureMarshal :: C_ClosureMarshal -> IO (FunPtr C_ClosureMarshal)
- noClosureMarshal :: Maybe ClosureMarshal
- wrap_ClosureMarshal :: Maybe (Ptr (FunPtr C_ClosureMarshal)) -> ClosureMarshal -> C_ClosureMarshal
- type C_ClosureMarshalFieldCallback = Ptr (GClosure ()) -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()
- type ClosureMarshalFieldCallback = GClosure () -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> IO ()
- dynamic_ClosureMarshalFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ClosureMarshalFieldCallback -> GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
- genClosure_ClosureMarshalFieldCallback :: MonadIO m => ClosureMarshalFieldCallback -> m (GClosure C_ClosureMarshalFieldCallback)
- mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback)
- noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback
- wrap_ClosureMarshalFieldCallback :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) -> ClosureMarshalFieldCallback -> C_ClosureMarshalFieldCallback
- type C_ClosureNotify = Ptr () -> Ptr (GClosure ()) -> IO ()
- type ClosureNotify = Ptr () -> GClosure () -> IO ()
- dynamic_ClosureNotify :: (HasCallStack, MonadIO m) => FunPtr C_ClosureNotify -> Ptr () -> GClosure a -> m ()
- genClosure_ClosureNotify :: MonadIO m => ClosureNotify -> m (GClosure C_ClosureNotify)
- mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify)
- noClosureNotify :: Maybe ClosureNotify
- wrap_ClosureNotify :: Maybe (Ptr (FunPtr C_ClosureNotify)) -> ClosureNotify -> C_ClosureNotify
- type C_InitiallyUnownedClassConstructedFieldCallback = Ptr Object -> IO ()
- type InitiallyUnownedClassConstructedFieldCallback = Object -> IO ()
- dynamic_InitiallyUnownedClassConstructedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassConstructedFieldCallback -> a -> m ()
- genClosure_InitiallyUnownedClassConstructedFieldCallback :: MonadIO m => InitiallyUnownedClassConstructedFieldCallback -> m (GClosure C_InitiallyUnownedClassConstructedFieldCallback)
- mk_InitiallyUnownedClassConstructedFieldCallback :: C_InitiallyUnownedClassConstructedFieldCallback -> IO (FunPtr C_InitiallyUnownedClassConstructedFieldCallback)
- noInitiallyUnownedClassConstructedFieldCallback :: Maybe InitiallyUnownedClassConstructedFieldCallback
- wrap_InitiallyUnownedClassConstructedFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassConstructedFieldCallback)) -> InitiallyUnownedClassConstructedFieldCallback -> C_InitiallyUnownedClassConstructedFieldCallback
- type C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback = Ptr Object -> Word32 -> Ptr GParamSpec -> IO ()
- type InitiallyUnownedClassDispatchPropertiesChangedFieldCallback = Object -> Word32 -> GParamSpec -> IO ()
- dynamic_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()
- genClosure_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: MonadIO m => InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> m (GClosure C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
- mk_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> IO (FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)
- noInitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
- wrap_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)) -> InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback
- type C_InitiallyUnownedClassDisposeFieldCallback = Ptr Object -> IO ()
- type InitiallyUnownedClassDisposeFieldCallback = Object -> IO ()
- dynamic_InitiallyUnownedClassDisposeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()
- genClosure_InitiallyUnownedClassDisposeFieldCallback :: MonadIO m => InitiallyUnownedClassDisposeFieldCallback -> m (GClosure C_InitiallyUnownedClassDisposeFieldCallback)
- mk_InitiallyUnownedClassDisposeFieldCallback :: C_InitiallyUnownedClassDisposeFieldCallback -> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)
- noInitiallyUnownedClassDisposeFieldCallback :: Maybe InitiallyUnownedClassDisposeFieldCallback
- wrap_InitiallyUnownedClassDisposeFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)) -> InitiallyUnownedClassDisposeFieldCallback -> C_InitiallyUnownedClassDisposeFieldCallback
- type C_InitiallyUnownedClassFinalizeFieldCallback = Ptr Object -> IO ()
- type InitiallyUnownedClassFinalizeFieldCallback = Object -> IO ()
- dynamic_InitiallyUnownedClassFinalizeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassFinalizeFieldCallback -> a -> m ()
- genClosure_InitiallyUnownedClassFinalizeFieldCallback :: MonadIO m => InitiallyUnownedClassFinalizeFieldCallback -> m (GClosure C_InitiallyUnownedClassFinalizeFieldCallback)
- mk_InitiallyUnownedClassFinalizeFieldCallback :: C_InitiallyUnownedClassFinalizeFieldCallback -> IO (FunPtr C_InitiallyUnownedClassFinalizeFieldCallback)
- noInitiallyUnownedClassFinalizeFieldCallback :: Maybe InitiallyUnownedClassFinalizeFieldCallback
- wrap_InitiallyUnownedClassFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassFinalizeFieldCallback)) -> InitiallyUnownedClassFinalizeFieldCallback -> C_InitiallyUnownedClassFinalizeFieldCallback
- type C_InitiallyUnownedClassGetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
- type InitiallyUnownedClassGetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO ()
- dynamic_InitiallyUnownedClassGetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()
- genClosure_InitiallyUnownedClassGetPropertyFieldCallback :: MonadIO m => InitiallyUnownedClassGetPropertyFieldCallback -> m (GClosure C_InitiallyUnownedClassGetPropertyFieldCallback)
- mk_InitiallyUnownedClassGetPropertyFieldCallback :: C_InitiallyUnownedClassGetPropertyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback)
- noInitiallyUnownedClassGetPropertyFieldCallback :: Maybe InitiallyUnownedClassGetPropertyFieldCallback
- wrap_InitiallyUnownedClassGetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback)) -> InitiallyUnownedClassGetPropertyFieldCallback -> C_InitiallyUnownedClassGetPropertyFieldCallback
- type C_InitiallyUnownedClassNotifyFieldCallback = Ptr Object -> Ptr GParamSpec -> IO ()
- type InitiallyUnownedClassNotifyFieldCallback = Object -> GParamSpec -> IO ()
- dynamic_InitiallyUnownedClassNotifyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> a -> GParamSpec -> m ()
- genClosure_InitiallyUnownedClassNotifyFieldCallback :: MonadIO m => InitiallyUnownedClassNotifyFieldCallback -> m (GClosure C_InitiallyUnownedClassNotifyFieldCallback)
- mk_InitiallyUnownedClassNotifyFieldCallback :: C_InitiallyUnownedClassNotifyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)
- noInitiallyUnownedClassNotifyFieldCallback :: Maybe InitiallyUnownedClassNotifyFieldCallback
- wrap_InitiallyUnownedClassNotifyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)) -> InitiallyUnownedClassNotifyFieldCallback -> C_InitiallyUnownedClassNotifyFieldCallback
- type C_InitiallyUnownedClassSetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
- type InitiallyUnownedClassSetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO ()
- dynamic_InitiallyUnownedClassSetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()
- genClosure_InitiallyUnownedClassSetPropertyFieldCallback :: MonadIO m => InitiallyUnownedClassSetPropertyFieldCallback -> m (GClosure C_InitiallyUnownedClassSetPropertyFieldCallback)
- mk_InitiallyUnownedClassSetPropertyFieldCallback :: C_InitiallyUnownedClassSetPropertyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)
- noInitiallyUnownedClassSetPropertyFieldCallback :: Maybe InitiallyUnownedClassSetPropertyFieldCallback
- wrap_InitiallyUnownedClassSetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)) -> InitiallyUnownedClassSetPropertyFieldCallback -> C_InitiallyUnownedClassSetPropertyFieldCallback
- type C_InstanceInitFunc = Ptr TypeInstance -> Ptr TypeClass -> IO ()
- type InstanceInitFunc = TypeInstance -> TypeClass -> IO ()
- dynamic_InstanceInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_InstanceInitFunc -> TypeInstance -> TypeClass -> m ()
- genClosure_InstanceInitFunc :: MonadIO m => InstanceInitFunc -> m (GClosure C_InstanceInitFunc)
- mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)
- noInstanceInitFunc :: Maybe InstanceInitFunc
- wrap_InstanceInitFunc :: Maybe (Ptr (FunPtr C_InstanceInitFunc)) -> InstanceInitFunc -> C_InstanceInitFunc
- type C_InterfaceFinalizeFunc = Ptr TypeInterface -> Ptr () -> IO ()
- type InterfaceFinalizeFunc = TypeInterface -> Ptr () -> IO ()
- dynamic_InterfaceFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_InterfaceFinalizeFunc -> TypeInterface -> Ptr () -> m ()
- genClosure_InterfaceFinalizeFunc :: MonadIO m => InterfaceFinalizeFunc -> m (GClosure C_InterfaceFinalizeFunc)
- mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc)
- noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc
- wrap_InterfaceFinalizeFunc :: Maybe (Ptr (FunPtr C_InterfaceFinalizeFunc)) -> InterfaceFinalizeFunc -> C_InterfaceFinalizeFunc
- type C_InterfaceInitFunc = Ptr TypeInterface -> Ptr () -> IO ()
- type InterfaceInitFunc = TypeInterface -> Ptr () -> IO ()
- dynamic_InterfaceInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_InterfaceInitFunc -> TypeInterface -> Ptr () -> m ()
- genClosure_InterfaceInitFunc :: MonadIO m => InterfaceInitFunc -> m (GClosure C_InterfaceInitFunc)
- mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)
- noInterfaceInitFunc :: Maybe InterfaceInitFunc
- wrap_InterfaceInitFunc :: Maybe (Ptr (FunPtr C_InterfaceInitFunc)) -> InterfaceInitFunc -> C_InterfaceInitFunc
- type C_ObjectClassConstructedFieldCallback = Ptr Object -> IO ()
- type ObjectClassConstructedFieldCallback = Object -> IO ()
- dynamic_ObjectClassConstructedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassConstructedFieldCallback -> a -> m ()
- genClosure_ObjectClassConstructedFieldCallback :: MonadIO m => ObjectClassConstructedFieldCallback -> m (GClosure C_ObjectClassConstructedFieldCallback)
- mk_ObjectClassConstructedFieldCallback :: C_ObjectClassConstructedFieldCallback -> IO (FunPtr C_ObjectClassConstructedFieldCallback)
- noObjectClassConstructedFieldCallback :: Maybe ObjectClassConstructedFieldCallback
- wrap_ObjectClassConstructedFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassConstructedFieldCallback)) -> ObjectClassConstructedFieldCallback -> C_ObjectClassConstructedFieldCallback
- type C_ObjectClassDispatchPropertiesChangedFieldCallback = Ptr Object -> Word32 -> Ptr GParamSpec -> IO ()
- type ObjectClassDispatchPropertiesChangedFieldCallback = Object -> Word32 -> GParamSpec -> IO ()
- dynamic_ObjectClassDispatchPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()
- genClosure_ObjectClassDispatchPropertiesChangedFieldCallback :: MonadIO m => ObjectClassDispatchPropertiesChangedFieldCallback -> m (GClosure C_ObjectClassDispatchPropertiesChangedFieldCallback)
- mk_ObjectClassDispatchPropertiesChangedFieldCallback :: C_ObjectClassDispatchPropertiesChangedFieldCallback -> IO (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)
- noObjectClassDispatchPropertiesChangedFieldCallback :: Maybe ObjectClassDispatchPropertiesChangedFieldCallback
- wrap_ObjectClassDispatchPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)) -> ObjectClassDispatchPropertiesChangedFieldCallback -> C_ObjectClassDispatchPropertiesChangedFieldCallback
- type C_ObjectClassDisposeFieldCallback = Ptr Object -> IO ()
- type ObjectClassDisposeFieldCallback = Object -> IO ()
- dynamic_ObjectClassDisposeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()
- genClosure_ObjectClassDisposeFieldCallback :: MonadIO m => ObjectClassDisposeFieldCallback -> m (GClosure C_ObjectClassDisposeFieldCallback)
- mk_ObjectClassDisposeFieldCallback :: C_ObjectClassDisposeFieldCallback -> IO (FunPtr C_ObjectClassDisposeFieldCallback)
- noObjectClassDisposeFieldCallback :: Maybe ObjectClassDisposeFieldCallback
- wrap_ObjectClassDisposeFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDisposeFieldCallback)) -> ObjectClassDisposeFieldCallback -> C_ObjectClassDisposeFieldCallback
- type C_ObjectClassFinalizeFieldCallback = Ptr Object -> IO ()
- type ObjectClassFinalizeFieldCallback = Object -> IO ()
- dynamic_ObjectClassFinalizeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassFinalizeFieldCallback -> a -> m ()
- genClosure_ObjectClassFinalizeFieldCallback :: MonadIO m => ObjectClassFinalizeFieldCallback -> m (GClosure C_ObjectClassFinalizeFieldCallback)
- mk_ObjectClassFinalizeFieldCallback :: C_ObjectClassFinalizeFieldCallback -> IO (FunPtr C_ObjectClassFinalizeFieldCallback)
- noObjectClassFinalizeFieldCallback :: Maybe ObjectClassFinalizeFieldCallback
- wrap_ObjectClassFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassFinalizeFieldCallback)) -> ObjectClassFinalizeFieldCallback -> C_ObjectClassFinalizeFieldCallback
- type C_ObjectClassGetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
- type ObjectClassGetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO ()
- dynamic_ObjectClassGetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassGetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()
- genClosure_ObjectClassGetPropertyFieldCallback :: MonadIO m => ObjectClassGetPropertyFieldCallback -> m (GClosure C_ObjectClassGetPropertyFieldCallback)
- mk_ObjectClassGetPropertyFieldCallback :: C_ObjectClassGetPropertyFieldCallback -> IO (FunPtr C_ObjectClassGetPropertyFieldCallback)
- noObjectClassGetPropertyFieldCallback :: Maybe ObjectClassGetPropertyFieldCallback
- wrap_ObjectClassGetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassGetPropertyFieldCallback)) -> ObjectClassGetPropertyFieldCallback -> C_ObjectClassGetPropertyFieldCallback
- type C_ObjectClassNotifyFieldCallback = Ptr Object -> Ptr GParamSpec -> IO ()
- type ObjectClassNotifyFieldCallback = Object -> GParamSpec -> IO ()
- dynamic_ObjectClassNotifyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassNotifyFieldCallback -> a -> GParamSpec -> m ()
- genClosure_ObjectClassNotifyFieldCallback :: MonadIO m => ObjectClassNotifyFieldCallback -> m (GClosure C_ObjectClassNotifyFieldCallback)
- mk_ObjectClassNotifyFieldCallback :: C_ObjectClassNotifyFieldCallback -> IO (FunPtr C_ObjectClassNotifyFieldCallback)
- noObjectClassNotifyFieldCallback :: Maybe ObjectClassNotifyFieldCallback
- wrap_ObjectClassNotifyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassNotifyFieldCallback)) -> ObjectClassNotifyFieldCallback -> C_ObjectClassNotifyFieldCallback
- type C_ObjectClassSetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
- type ObjectClassSetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO ()
- dynamic_ObjectClassSetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassSetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()
- genClosure_ObjectClassSetPropertyFieldCallback :: MonadIO m => ObjectClassSetPropertyFieldCallback -> m (GClosure C_ObjectClassSetPropertyFieldCallback)
- mk_ObjectClassSetPropertyFieldCallback :: C_ObjectClassSetPropertyFieldCallback -> IO (FunPtr C_ObjectClassSetPropertyFieldCallback)
- noObjectClassSetPropertyFieldCallback :: Maybe ObjectClassSetPropertyFieldCallback
- wrap_ObjectClassSetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)) -> ObjectClassSetPropertyFieldCallback -> C_ObjectClassSetPropertyFieldCallback
- type C_ObjectFinalizeFunc = Ptr Object -> IO ()
- type ObjectFinalizeFunc = Object -> IO ()
- dynamic_ObjectFinalizeFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectFinalizeFunc -> a -> m ()
- genClosure_ObjectFinalizeFunc :: MonadIO m => ObjectFinalizeFunc -> m (GClosure C_ObjectFinalizeFunc)
- mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)
- noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc
- wrap_ObjectFinalizeFunc :: Maybe (Ptr (FunPtr C_ObjectFinalizeFunc)) -> ObjectFinalizeFunc -> C_ObjectFinalizeFunc
- type C_ObjectGetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
- type ObjectGetPropertyFunc = Object -> Word32 -> GValue -> GParamSpec -> IO ()
- dynamic_ObjectGetPropertyFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectGetPropertyFunc -> a -> Word32 -> GValue -> GParamSpec -> m ()
- genClosure_ObjectGetPropertyFunc :: MonadIO m => ObjectGetPropertyFunc -> m (GClosure C_ObjectGetPropertyFunc)
- mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc)
- noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc
- wrap_ObjectGetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectGetPropertyFunc)) -> ObjectGetPropertyFunc -> C_ObjectGetPropertyFunc
- type C_ObjectSetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
- type ObjectSetPropertyFunc = Object -> Word32 -> GValue -> GParamSpec -> IO ()
- dynamic_ObjectSetPropertyFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectSetPropertyFunc -> a -> Word32 -> GValue -> GParamSpec -> m ()
- genClosure_ObjectSetPropertyFunc :: MonadIO m => ObjectSetPropertyFunc -> m (GClosure C_ObjectSetPropertyFunc)
- mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)
- noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc
- wrap_ObjectSetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) -> ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
- type C_ParamSpecTypeInfoFinalizeFieldCallback = Ptr GParamSpec -> IO ()
- type ParamSpecTypeInfoFinalizeFieldCallback = GParamSpec -> IO ()
- dynamic_ParamSpecTypeInfoFinalizeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> GParamSpec -> m ()
- genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: MonadIO m => ParamSpecTypeInfoFinalizeFieldCallback -> m (GClosure C_ParamSpecTypeInfoFinalizeFieldCallback)
- mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)
- noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback
- wrap_ParamSpecTypeInfoFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)) -> ParamSpecTypeInfoFinalizeFieldCallback -> C_ParamSpecTypeInfoFinalizeFieldCallback
- type C_ParamSpecTypeInfoInstanceInitFieldCallback = Ptr GParamSpec -> IO ()
- type ParamSpecTypeInfoInstanceInitFieldCallback = GParamSpec -> IO ()
- dynamic_ParamSpecTypeInfoInstanceInitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> GParamSpec -> m ()
- genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: MonadIO m => ParamSpecTypeInfoInstanceInitFieldCallback -> m (GClosure C_ParamSpecTypeInfoInstanceInitFieldCallback)
- mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)
- noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback
- wrap_ParamSpecTypeInfoInstanceInitFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)) -> ParamSpecTypeInfoInstanceInitFieldCallback -> C_ParamSpecTypeInfoInstanceInitFieldCallback
- type C_ParamSpecTypeInfoValueSetDefaultFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO ()
- type ParamSpecTypeInfoValueSetDefaultFieldCallback = GParamSpec -> GValue -> IO ()
- dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> GParamSpec -> GValue -> m ()
- genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: MonadIO m => ParamSpecTypeInfoValueSetDefaultFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
- mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
- noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback
- wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)) -> ParamSpecTypeInfoValueSetDefaultFieldCallback -> C_ParamSpecTypeInfoValueSetDefaultFieldCallback
- type C_ParamSpecTypeInfoValueValidateFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO CInt
- type ParamSpecTypeInfoValueValidateFieldCallback = GParamSpec -> GValue -> IO Bool
- dynamic_ParamSpecTypeInfoValueValidateFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> GParamSpec -> GValue -> m Bool
- genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: MonadIO m => ParamSpecTypeInfoValueValidateFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueValidateFieldCallback)
- mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)
- noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback
- wrap_ParamSpecTypeInfoValueValidateFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)) -> ParamSpecTypeInfoValueValidateFieldCallback -> C_ParamSpecTypeInfoValueValidateFieldCallback
- type C_ParamSpecTypeInfoValuesCmpFieldCallback = Ptr GParamSpec -> Ptr GValue -> Ptr GValue -> IO Int32
- type ParamSpecTypeInfoValuesCmpFieldCallback = GParamSpec -> GValue -> GValue -> IO Int32
- dynamic_ParamSpecTypeInfoValuesCmpFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> GParamSpec -> GValue -> GValue -> m Int32
- genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: MonadIO m => ParamSpecTypeInfoValuesCmpFieldCallback -> m (GClosure C_ParamSpecTypeInfoValuesCmpFieldCallback)
- mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)
- noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback
- wrap_ParamSpecTypeInfoValuesCmpFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)) -> ParamSpecTypeInfoValuesCmpFieldCallback -> C_ParamSpecTypeInfoValuesCmpFieldCallback
- type C_SignalAccumulator = Ptr SignalInvocationHint -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt
- type SignalAccumulator = SignalInvocationHint -> GValue -> GValue -> Ptr () -> IO Bool
- dynamic_SignalAccumulator :: (HasCallStack, MonadIO m) => FunPtr C_SignalAccumulator -> SignalInvocationHint -> GValue -> GValue -> Ptr () -> m Bool
- genClosure_SignalAccumulator :: MonadIO m => SignalAccumulator -> m (GClosure C_SignalAccumulator)
- mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)
- noSignalAccumulator :: Maybe SignalAccumulator
- wrap_SignalAccumulator :: Maybe (Ptr (FunPtr C_SignalAccumulator)) -> SignalAccumulator -> C_SignalAccumulator
- type C_SignalEmissionHook = Ptr SignalInvocationHint -> Word32 -> Ptr GValue -> Ptr () -> IO CInt
- type SignalEmissionHook = SignalInvocationHint -> [GValue] -> Ptr () -> IO Bool
- dynamic_SignalEmissionHook :: (HasCallStack, MonadIO m) => FunPtr C_SignalEmissionHook -> SignalInvocationHint -> [GValue] -> Ptr () -> m Bool
- genClosure_SignalEmissionHook :: MonadIO m => SignalEmissionHook -> m (GClosure C_SignalEmissionHook)
- mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)
- noSignalEmissionHook :: Maybe SignalEmissionHook
- wrap_SignalEmissionHook :: Maybe (Ptr (FunPtr C_SignalEmissionHook)) -> SignalEmissionHook -> C_SignalEmissionHook
- type C_ToggleNotify = Ptr () -> Ptr Object -> CInt -> IO ()
- type ToggleNotify = Ptr () -> Object -> Bool -> IO ()
- dynamic_ToggleNotify :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ToggleNotify -> Ptr () -> a -> Bool -> m ()
- genClosure_ToggleNotify :: MonadIO m => ToggleNotify -> m (GClosure C_ToggleNotify)
- mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify)
- noToggleNotify :: Maybe ToggleNotify
- wrap_ToggleNotify :: Maybe (Ptr (FunPtr C_ToggleNotify)) -> ToggleNotify -> C_ToggleNotify
- type C_TypeClassCacheFunc = Ptr () -> Ptr TypeClass -> IO CInt
- type TypeClassCacheFunc = Ptr () -> TypeClass -> IO Bool
- dynamic_TypeClassCacheFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeClassCacheFunc -> Ptr () -> TypeClass -> m Bool
- genClosure_TypeClassCacheFunc :: MonadIO m => TypeClassCacheFunc -> m (GClosure C_TypeClassCacheFunc)
- mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)
- noTypeClassCacheFunc :: Maybe TypeClassCacheFunc
- wrap_TypeClassCacheFunc :: Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) -> TypeClassCacheFunc -> C_TypeClassCacheFunc
- type C_TypeInterfaceCheckFunc = Ptr () -> Ptr TypeInterface -> IO ()
- type TypeInterfaceCheckFunc = Ptr () -> TypeInterface -> IO ()
- dynamic_TypeInterfaceCheckFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeInterfaceCheckFunc -> Ptr () -> TypeInterface -> m ()
- genClosure_TypeInterfaceCheckFunc :: MonadIO m => TypeInterfaceCheckFunc -> m (GClosure C_TypeInterfaceCheckFunc)
- mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)
- noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc
- wrap_TypeInterfaceCheckFunc :: Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc)) -> TypeInterfaceCheckFunc -> C_TypeInterfaceCheckFunc
- type C_TypePluginCompleteInterfaceInfo = Ptr TypePlugin -> CGType -> CGType -> Ptr InterfaceInfo -> IO ()
- type TypePluginCompleteInterfaceInfo = TypePlugin -> GType -> GType -> InterfaceInfo -> IO ()
- dynamic_TypePluginCompleteInterfaceInfo :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginCompleteInterfaceInfo -> a -> GType -> GType -> InterfaceInfo -> m ()
- genClosure_TypePluginCompleteInterfaceInfo :: MonadIO m => TypePluginCompleteInterfaceInfo -> m (GClosure C_TypePluginCompleteInterfaceInfo)
- mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo)
- noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo
- wrap_TypePluginCompleteInterfaceInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) -> TypePluginCompleteInterfaceInfo -> C_TypePluginCompleteInterfaceInfo
- type C_TypePluginCompleteTypeInfo = Ptr TypePlugin -> CGType -> Ptr TypeInfo -> Ptr TypeValueTable -> IO ()
- type TypePluginCompleteTypeInfo = TypePlugin -> GType -> TypeInfo -> TypeValueTable -> IO ()
- dynamic_TypePluginCompleteTypeInfo :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginCompleteTypeInfo -> a -> GType -> TypeInfo -> TypeValueTable -> m ()
- genClosure_TypePluginCompleteTypeInfo :: MonadIO m => TypePluginCompleteTypeInfo -> m (GClosure C_TypePluginCompleteTypeInfo)
- mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo)
- noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo
- wrap_TypePluginCompleteTypeInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) -> TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo
- type C_TypePluginUnuse = Ptr TypePlugin -> IO ()
- type TypePluginUnuse = TypePlugin -> IO ()
- dynamic_TypePluginUnuse :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginUnuse -> a -> m ()
- genClosure_TypePluginUnuse :: MonadIO m => TypePluginUnuse -> m (GClosure C_TypePluginUnuse)
- mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse)
- noTypePluginUnuse :: Maybe TypePluginUnuse
- wrap_TypePluginUnuse :: Maybe (Ptr (FunPtr C_TypePluginUnuse)) -> TypePluginUnuse -> C_TypePluginUnuse
- type C_TypePluginUse = Ptr TypePlugin -> IO ()
- type TypePluginUse = TypePlugin -> IO ()
- dynamic_TypePluginUse :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginUse -> a -> m ()
- genClosure_TypePluginUse :: MonadIO m => TypePluginUse -> m (GClosure C_TypePluginUse)
- mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse)
- noTypePluginUse :: Maybe TypePluginUse
- wrap_TypePluginUse :: Maybe (Ptr (FunPtr C_TypePluginUse)) -> TypePluginUse -> C_TypePluginUse
- type C_TypeValueCollectFunc = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString
- type TypeValueCollectFunc = GValue -> [TypeCValue] -> Word32 -> IO (Maybe Text)
- dynamic_TypeValueCollectFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueCollectFunc -> GValue -> [TypeCValue] -> Word32 -> m (Maybe Text)
- genClosure_TypeValueCollectFunc :: MonadIO m => TypeValueCollectFunc -> m (GClosure C_TypeValueCollectFunc)
- mk_TypeValueCollectFunc :: C_TypeValueCollectFunc -> IO (FunPtr C_TypeValueCollectFunc)
- noTypeValueCollectFunc :: Maybe TypeValueCollectFunc
- wrap_TypeValueCollectFunc :: Maybe (Ptr (FunPtr C_TypeValueCollectFunc)) -> TypeValueCollectFunc -> C_TypeValueCollectFunc
- type C_TypeValueCopyFunc = Ptr GValue -> Ptr GValue -> IO ()
- type TypeValueCopyFunc = GValue -> IO GValue
- dynamic_TypeValueCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueCopyFunc -> GValue -> m GValue
- genClosure_TypeValueCopyFunc :: MonadIO m => TypeValueCopyFunc -> m (GClosure C_TypeValueCopyFunc)
- mk_TypeValueCopyFunc :: C_TypeValueCopyFunc -> IO (FunPtr C_TypeValueCopyFunc)
- noTypeValueCopyFunc :: Maybe TypeValueCopyFunc
- wrap_TypeValueCopyFunc :: Maybe (Ptr (FunPtr C_TypeValueCopyFunc)) -> TypeValueCopyFunc -> C_TypeValueCopyFunc
- type C_TypeValueFreeFunc = Ptr GValue -> IO ()
- type TypeValueFreeFunc = GValue -> IO ()
- dynamic_TypeValueFreeFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueFreeFunc -> GValue -> m ()
- genClosure_TypeValueFreeFunc :: MonadIO m => TypeValueFreeFunc -> m (GClosure C_TypeValueFreeFunc)
- mk_TypeValueFreeFunc :: C_TypeValueFreeFunc -> IO (FunPtr C_TypeValueFreeFunc)
- noTypeValueFreeFunc :: Maybe TypeValueFreeFunc
- wrap_TypeValueFreeFunc :: Maybe (Ptr (FunPtr C_TypeValueFreeFunc)) -> TypeValueFreeFunc -> C_TypeValueFreeFunc
- type C_TypeValueInitFunc = Ptr GValue -> IO ()
- type TypeValueInitFunc = GValue -> IO ()
- dynamic_TypeValueInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueInitFunc -> GValue -> m ()
- genClosure_TypeValueInitFunc :: MonadIO m => TypeValueInitFunc -> m (GClosure C_TypeValueInitFunc)
- mk_TypeValueInitFunc :: C_TypeValueInitFunc -> IO (FunPtr C_TypeValueInitFunc)
- noTypeValueInitFunc :: Maybe TypeValueInitFunc
- wrap_TypeValueInitFunc :: Maybe (Ptr (FunPtr C_TypeValueInitFunc)) -> TypeValueInitFunc -> C_TypeValueInitFunc
- type C_TypeValueLCopyFunc = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString
- type TypeValueLCopyFunc = GValue -> [TypeCValue] -> Word32 -> IO (Maybe Text)
- dynamic_TypeValueLCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueLCopyFunc -> GValue -> [TypeCValue] -> Word32 -> m (Maybe Text)
- genClosure_TypeValueLCopyFunc :: MonadIO m => TypeValueLCopyFunc -> m (GClosure C_TypeValueLCopyFunc)
- mk_TypeValueLCopyFunc :: C_TypeValueLCopyFunc -> IO (FunPtr C_TypeValueLCopyFunc)
- noTypeValueLCopyFunc :: Maybe TypeValueLCopyFunc
- wrap_TypeValueLCopyFunc :: Maybe (Ptr (FunPtr C_TypeValueLCopyFunc)) -> TypeValueLCopyFunc -> C_TypeValueLCopyFunc
- type C_TypeValuePeekPointerFunc = Ptr GValue -> IO (Ptr ())
- type TypeValuePeekPointerFunc = GValue -> IO (Ptr ())
- dynamic_TypeValuePeekPointerFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValuePeekPointerFunc -> GValue -> m (Ptr ())
- genClosure_TypeValuePeekPointerFunc :: MonadIO m => TypeValuePeekPointerFunc -> m (GClosure C_TypeValuePeekPointerFunc)
- mk_TypeValuePeekPointerFunc :: C_TypeValuePeekPointerFunc -> IO (FunPtr C_TypeValuePeekPointerFunc)
- noTypeValuePeekPointerFunc :: Maybe TypeValuePeekPointerFunc
- wrap_TypeValuePeekPointerFunc :: Maybe (Ptr (FunPtr C_TypeValuePeekPointerFunc)) -> TypeValuePeekPointerFunc -> C_TypeValuePeekPointerFunc
- type C_ValueTransform = Ptr GValue -> Ptr GValue -> IO ()
- type ValueTransform = GValue -> GValue -> IO ()
- dynamic_ValueTransform :: (HasCallStack, MonadIO m) => FunPtr C_ValueTransform -> GValue -> GValue -> m ()
- genClosure_ValueTransform :: MonadIO m => ValueTransform -> m (GClosure C_ValueTransform)
- mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform)
- noValueTransform :: Maybe ValueTransform
- wrap_ValueTransform :: Maybe (Ptr (FunPtr C_ValueTransform)) -> ValueTransform -> C_ValueTransform
- type C_WeakNotify = Ptr () -> Ptr Object -> IO ()
- type WeakNotify = Ptr () -> Object -> IO ()
- dynamic_WeakNotify :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_WeakNotify -> Ptr () -> a -> m ()
- genClosure_WeakNotify :: MonadIO m => WeakNotify -> m (GClosure C_WeakNotify)
- mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify)
- noWeakNotify :: Maybe WeakNotify
- wrap_WeakNotify :: Maybe (Ptr (FunPtr C_WeakNotify)) -> WeakNotify -> C_WeakNotify

# Signals

## BaseFinalizeFunc

type BaseFinalizeFunc Source #

Arguments

= TypeClass | `gClass`: The `TypeClass` structure to finalize
-> IO () |

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 C_BaseFinalizeFunc = Ptr TypeClass -> IO () Source #

Type for the callback on the (unwrapped) C side.

dynamic_BaseFinalizeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_BaseFinalizeFunc |
-> TypeClass | `gClass`: The `TypeClass` structure to finalize
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BaseFinalizeFunc :: MonadIO m => BaseFinalizeFunc -> m (GClosure C_BaseFinalizeFunc) Source #

Wrap the callback into a `GClosure`.

mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc) Source #

Generate a function pointer callable from C code, from a `C_BaseFinalizeFunc`.

noBaseFinalizeFunc :: Maybe BaseFinalizeFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `BaseFinalizeFunc``.

wrap_BaseFinalizeFunc :: Maybe (Ptr (FunPtr C_BaseFinalizeFunc)) -> BaseFinalizeFunc -> C_BaseFinalizeFunc Source #

Wrap a `BaseFinalizeFunc` into a `C_BaseFinalizeFunc`.

## BaseInitFunc

type BaseInitFunc Source #

Arguments

= TypeClass | `gClass`: The `TypeClass` structure to initialize
-> IO () |

A callback function used by the type system to do base initialization of the class structures of derived types.

This function 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 C_BaseInitFunc = Ptr TypeClass -> IO () Source #

Type for the callback on the (unwrapped) C side.

dynamic_BaseInitFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_BaseInitFunc |
-> TypeClass | `gClass`: The `TypeClass` structure to initialize
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BaseInitFunc :: MonadIO m => BaseInitFunc -> m (GClosure C_BaseInitFunc) Source #

Wrap the callback into a `GClosure`.

mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc) Source #

Generate a function pointer callable from C code, from a `C_BaseInitFunc`.

noBaseInitFunc :: Maybe BaseInitFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `BaseInitFunc``.

wrap_BaseInitFunc :: Maybe (Ptr (FunPtr C_BaseInitFunc)) -> BaseInitFunc -> C_BaseInitFunc Source #

Wrap a `BaseInitFunc` into a `C_BaseInitFunc`.

## BindingTransformFunc

type BindingTransformFunc Source #

Arguments

= Binding | `binding`: a `Binding`
-> GValue | `fromValue`: the `Value` containing the value to transform
-> GValue | `toValue`: the `Value` in which to store the transformed value
-> IO Bool | Returns: `True` if the transformation was successful, and `False` otherwise

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 `BindingFlagsBidirectional` binding, then those roles are reversed.

Since: 2.26

type BindingTransformFunc_WithClosures Source #

Arguments

= Binding | `binding`: a `Binding`
-> GValue | `fromValue`: the `Value` containing the value to transform
-> GValue | `toValue`: the `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 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 `BindingFlagsBidirectional` binding, then those roles are reversed.

Since: 2.26

type C_BindingTransformFunc = Ptr Binding -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt Source #

Type for the callback on the (unwrapped) C side.

drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BindingTransformFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsBinding a) |
=> FunPtr C_BindingTransformFunc |
-> a | `binding`: a `Binding`
-> GValue | `fromValue`: the `Value` containing the value to transform
-> GValue | `toValue`: the `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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BindingTransformFunc :: MonadIO m => BindingTransformFunc -> m (GClosure C_BindingTransformFunc) Source #

Wrap the callback into a `GClosure`.

mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc) Source #

Generate a function pointer callable from C code, from a `C_BindingTransformFunc`.

noBindingTransformFunc :: Maybe BindingTransformFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `BindingTransformFunc``.

noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures Source #

A convenience synonym for ``Nothing` :: `Maybe` `BindingTransformFunc_WithClosures``.

wrap_BindingTransformFunc :: Maybe (Ptr (FunPtr C_BindingTransformFunc)) -> BindingTransformFunc_WithClosures -> C_BindingTransformFunc Source #

Wrap a `BindingTransformFunc` into a `C_BindingTransformFunc`.

## BoxedCopyFunc

type BoxedCopyFunc Source #

Arguments

= Ptr () | `boxed`: The boxed structure to be copied.
-> IO (Ptr ()) | Returns: The newly created copy of the boxed structure.

This function is provided by the user and should produce a copy of the passed in boxed structure.

type C_BoxedCopyFunc = Ptr () -> IO (Ptr ()) Source #

Type for the callback on the (unwrapped) C side.

dynamic_BoxedCopyFunc Source #

Arguments

:: (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.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BoxedCopyFunc :: MonadIO m => BoxedCopyFunc -> m (GClosure C_BoxedCopyFunc) Source #

Wrap the callback into a `GClosure`.

mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc) Source #

Generate a function pointer callable from C code, from a `C_BoxedCopyFunc`.

noBoxedCopyFunc :: Maybe BoxedCopyFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `BoxedCopyFunc``.

wrap_BoxedCopyFunc :: Maybe (Ptr (FunPtr C_BoxedCopyFunc)) -> BoxedCopyFunc -> C_BoxedCopyFunc Source #

Wrap a `BoxedCopyFunc` into a `C_BoxedCopyFunc`.

## BoxedFreeFunc

type BoxedFreeFunc Source #

Arguments

= Ptr () | `boxed`: The boxed structure to be freed.
-> IO () |

This function is provided by the user and should free the boxed structure passed.

type C_BoxedFreeFunc = Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

dynamic_BoxedFreeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_BoxedFreeFunc |
-> Ptr () | `boxed`: The boxed structure to be freed.
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BoxedFreeFunc :: MonadIO m => BoxedFreeFunc -> m (GClosure C_BoxedFreeFunc) Source #

Wrap the callback into a `GClosure`.

mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc) Source #

Generate a function pointer callable from C code, from a `C_BoxedFreeFunc`.

noBoxedFreeFunc :: Maybe BoxedFreeFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `BoxedFreeFunc``.

wrap_BoxedFreeFunc :: Maybe (Ptr (FunPtr C_BoxedFreeFunc)) -> BoxedFreeFunc -> C_BoxedFreeFunc Source #

Wrap a `BoxedFreeFunc` into a `C_BoxedFreeFunc`.

## Callback

type C_Callback = IO () Source #

Type for the callback on the (unwrapped) C side.

type Callback = IO () Source #

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 `Callback`.

dynamic_Callback :: (HasCallStack, MonadIO m) => FunPtr C_Callback -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback) Source #

Wrap the callback into a `GClosure`.

mk_Callback :: C_Callback -> IO (FunPtr C_Callback) Source #

Generate a function pointer callable from C code, from a `C_Callback`.

noCallback :: Maybe Callback Source #

A convenience synonym for ``Nothing` :: `Maybe` `Callback``.

wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback -> C_Callback Source #

Wrap a `Callback` into a `C_Callback`.

## ClassFinalizeFunc

type C_ClassFinalizeFunc = Ptr TypeClass -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ClassFinalizeFunc Source #

Arguments

= TypeClass | `gClass`: The `TypeClass` structure to finalize
-> Ptr () | `classData`: The `classData` member supplied via the `TypeInfo` structure
-> IO () |

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 `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).

dynamic_ClassFinalizeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ClassFinalizeFunc |
-> TypeClass | `gClass`: The `TypeClass` structure to finalize
-> Ptr () | `classData`: The `classData` member supplied via the `TypeInfo` structure
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClassFinalizeFunc :: MonadIO m => ClassFinalizeFunc -> m (GClosure C_ClassFinalizeFunc) Source #

Wrap the callback into a `GClosure`.

mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc) Source #

Generate a function pointer callable from C code, from a `C_ClassFinalizeFunc`.

noClassFinalizeFunc :: Maybe ClassFinalizeFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClassFinalizeFunc``.

wrap_ClassFinalizeFunc :: Maybe (Ptr (FunPtr C_ClassFinalizeFunc)) -> ClassFinalizeFunc -> C_ClassFinalizeFunc Source #

Wrap a `ClassFinalizeFunc` into a `C_ClassFinalizeFunc`.

## ClassInitFunc

type C_ClassInitFunc = Ptr TypeClass -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ClassInitFunc Source #

Arguments

= TypeClass | `gClass`: The `TypeClass` structure to initialize.
-> Ptr () | `classData`: The `classData` member supplied via the `TypeInfo` structure.
-> IO () |

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 `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.

dynamic_ClassInitFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ClassInitFunc |
-> TypeClass | `gClass`: The `TypeClass` structure to initialize.
-> Ptr () | `classData`: The `classData` member supplied via the `TypeInfo` structure.
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClassInitFunc :: MonadIO m => ClassInitFunc -> m (GClosure C_ClassInitFunc) Source #

Wrap the callback into a `GClosure`.

mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc) Source #

Generate a function pointer callable from C code, from a `C_ClassInitFunc`.

noClassInitFunc :: Maybe ClassInitFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClassInitFunc``.

wrap_ClassInitFunc :: Maybe (Ptr (FunPtr C_ClassInitFunc)) -> ClassInitFunc -> C_ClassInitFunc Source #

Wrap a `ClassInitFunc` into a `C_ClassInitFunc`.

## ClosureMarshal

type C_ClosureMarshal = Ptr (GClosure ()) -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ClosureMarshal Source #

Arguments

= GClosure () | `closure`: the `Closure` to which the marshaller belongs
-> Maybe GValue | `returnValue`: a `Value` to store the return value. May be `Nothing` if the callback of `closure` doesn't return a value.
-> [GValue] | `paramValues`: an array of `GValues` holding the arguments on which to invoke the callback of `closure`
-> Ptr () | `invocationHint`: the invocation hint given as the last argument to `closureInvoke`
-> Ptr () | `marshalData`: additional data specified when registering the marshaller, see `g_closure_set_marshal()` and `g_closure_set_meta_marshal()`
-> IO () |

The type used for marshaller functions.

dynamic_ClosureMarshal Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ClosureMarshal |
-> GClosure a | `closure`: the `Closure` to which the marshaller belongs
-> Maybe GValue | `returnValue`: a `Value` to store the return value. May be `Nothing` if the callback of `closure` doesn't return a value.
-> [GValue] | `paramValues`: an array of `GValues` holding the arguments on which to invoke the callback of `closure`
-> Ptr () | `invocationHint`: the invocation hint given as the last argument to `closureInvoke`
-> Ptr () | `marshalData`: additional data specified when registering the marshaller, see `g_closure_set_marshal()` and `g_closure_set_meta_marshal()`
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClosureMarshal :: MonadIO m => ClosureMarshal -> m (GClosure C_ClosureMarshal) Source #

Wrap the callback into a `GClosure`.

mk_ClosureMarshal :: C_ClosureMarshal -> IO (FunPtr C_ClosureMarshal) Source #

Generate a function pointer callable from C code, from a `C_ClosureMarshal`.

noClosureMarshal :: Maybe ClosureMarshal Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClosureMarshal``.

wrap_ClosureMarshal :: Maybe (Ptr (FunPtr C_ClosureMarshal)) -> ClosureMarshal -> C_ClosureMarshal Source #

Wrap a `ClosureMarshal` into a `C_ClosureMarshal`.

## ClosureMarshalFieldCallback

type C_ClosureMarshalFieldCallback = Ptr (GClosure ()) -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ClosureMarshalFieldCallback = GClosure () -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> IO () Source #

No description available in the introspection data.

dynamic_ClosureMarshalFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ClosureMarshalFieldCallback -> GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClosureMarshalFieldCallback :: MonadIO m => ClosureMarshalFieldCallback -> m (GClosure C_ClosureMarshalFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ClosureMarshalFieldCallback`.

noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClosureMarshalFieldCallback``.

wrap_ClosureMarshalFieldCallback :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) -> ClosureMarshalFieldCallback -> C_ClosureMarshalFieldCallback Source #

Wrap a `ClosureMarshalFieldCallback` into a `C_ClosureMarshalFieldCallback`.

## ClosureNotify

type C_ClosureNotify = Ptr () -> Ptr (GClosure ()) -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ClosureNotify Source #

Arguments

= Ptr () | `data`: data specified when registering the notification callback
-> GClosure () | `closure`: the `Closure` on which the notification is emitted
-> IO () |

The type used for the various notification callbacks which can be registered on closures.

dynamic_ClosureNotify Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ClosureNotify |
-> Ptr () | `data`: data specified when registering the notification callback
-> GClosure a | `closure`: the `Closure` on which the notification is emitted
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClosureNotify :: MonadIO m => ClosureNotify -> m (GClosure C_ClosureNotify) Source #

Wrap the callback into a `GClosure`.

mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify) Source #

Generate a function pointer callable from C code, from a `C_ClosureNotify`.

noClosureNotify :: Maybe ClosureNotify Source #

A convenience synonym for ``Nothing` :: `Maybe` `ClosureNotify``.

wrap_ClosureNotify :: Maybe (Ptr (FunPtr C_ClosureNotify)) -> ClosureNotify -> C_ClosureNotify Source #

Wrap a `ClosureNotify` into a `C_ClosureNotify`.

## InitiallyUnownedClassConstructedFieldCallback

type C_InitiallyUnownedClassConstructedFieldCallback = Ptr Object -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassConstructedFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_InitiallyUnownedClassConstructedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassConstructedFieldCallback -> a -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassConstructedFieldCallback :: MonadIO m => InitiallyUnownedClassConstructedFieldCallback -> m (GClosure C_InitiallyUnownedClassConstructedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_InitiallyUnownedClassConstructedFieldCallback :: C_InitiallyUnownedClassConstructedFieldCallback -> IO (FunPtr C_InitiallyUnownedClassConstructedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_InitiallyUnownedClassConstructedFieldCallback`.

noInitiallyUnownedClassConstructedFieldCallback :: Maybe InitiallyUnownedClassConstructedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `InitiallyUnownedClassConstructedFieldCallback``.

wrap_InitiallyUnownedClassConstructedFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassConstructedFieldCallback)) -> InitiallyUnownedClassConstructedFieldCallback -> C_InitiallyUnownedClassConstructedFieldCallback Source #

Wrap a `InitiallyUnownedClassConstructedFieldCallback` into a `C_InitiallyUnownedClassConstructedFieldCallback`.

## InitiallyUnownedClassDispatchPropertiesChangedFieldCallback

type C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback = Ptr Object -> Word32 -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassDispatchPropertiesChangedFieldCallback = Object -> Word32 -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: MonadIO m => InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> m (GClosure C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> IO (FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback`.

noInitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `InitiallyUnownedClassDispatchPropertiesChangedFieldCallback``.

wrap_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)) -> InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback Source #

Wrap a `InitiallyUnownedClassDispatchPropertiesChangedFieldCallback` into a `C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback`.

## InitiallyUnownedClassDisposeFieldCallback

type C_InitiallyUnownedClassDisposeFieldCallback = Ptr Object -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassDisposeFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_InitiallyUnownedClassDisposeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassDisposeFieldCallback :: MonadIO m => InitiallyUnownedClassDisposeFieldCallback -> m (GClosure C_InitiallyUnownedClassDisposeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_InitiallyUnownedClassDisposeFieldCallback :: C_InitiallyUnownedClassDisposeFieldCallback -> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_InitiallyUnownedClassDisposeFieldCallback`.

noInitiallyUnownedClassDisposeFieldCallback :: Maybe InitiallyUnownedClassDisposeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `InitiallyUnownedClassDisposeFieldCallback``.

wrap_InitiallyUnownedClassDisposeFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)) -> InitiallyUnownedClassDisposeFieldCallback -> C_InitiallyUnownedClassDisposeFieldCallback Source #

Wrap a `InitiallyUnownedClassDisposeFieldCallback` into a `C_InitiallyUnownedClassDisposeFieldCallback`.

## InitiallyUnownedClassFinalizeFieldCallback

type C_InitiallyUnownedClassFinalizeFieldCallback = Ptr Object -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassFinalizeFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_InitiallyUnownedClassFinalizeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassFinalizeFieldCallback -> a -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassFinalizeFieldCallback :: MonadIO m => InitiallyUnownedClassFinalizeFieldCallback -> m (GClosure C_InitiallyUnownedClassFinalizeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_InitiallyUnownedClassFinalizeFieldCallback :: C_InitiallyUnownedClassFinalizeFieldCallback -> IO (FunPtr C_InitiallyUnownedClassFinalizeFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_InitiallyUnownedClassFinalizeFieldCallback`.

noInitiallyUnownedClassFinalizeFieldCallback :: Maybe InitiallyUnownedClassFinalizeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `InitiallyUnownedClassFinalizeFieldCallback``.

wrap_InitiallyUnownedClassFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassFinalizeFieldCallback)) -> InitiallyUnownedClassFinalizeFieldCallback -> C_InitiallyUnownedClassFinalizeFieldCallback Source #

Wrap a `InitiallyUnownedClassFinalizeFieldCallback` into a `C_InitiallyUnownedClassFinalizeFieldCallback`.

## InitiallyUnownedClassGetPropertyFieldCallback

type C_InitiallyUnownedClassGetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassGetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_InitiallyUnownedClassGetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassGetPropertyFieldCallback :: MonadIO m => InitiallyUnownedClassGetPropertyFieldCallback -> m (GClosure C_InitiallyUnownedClassGetPropertyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_InitiallyUnownedClassGetPropertyFieldCallback :: C_InitiallyUnownedClassGetPropertyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_InitiallyUnownedClassGetPropertyFieldCallback`.

noInitiallyUnownedClassGetPropertyFieldCallback :: Maybe InitiallyUnownedClassGetPropertyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `InitiallyUnownedClassGetPropertyFieldCallback``.

wrap_InitiallyUnownedClassGetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback)) -> InitiallyUnownedClassGetPropertyFieldCallback -> C_InitiallyUnownedClassGetPropertyFieldCallback Source #

Wrap a `InitiallyUnownedClassGetPropertyFieldCallback` into a `C_InitiallyUnownedClassGetPropertyFieldCallback`.

## InitiallyUnownedClassNotifyFieldCallback

type C_InitiallyUnownedClassNotifyFieldCallback = Ptr Object -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassNotifyFieldCallback Source #

Arguments

= Object | `object`: a `Object`
-> GParamSpec |
-> IO () |

No description available in the introspection data.

dynamic_InitiallyUnownedClassNotifyFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) |
=> FunPtr C_InitiallyUnownedClassNotifyFieldCallback |
-> a | `object`: a `Object`
-> GParamSpec |
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassNotifyFieldCallback :: MonadIO m => InitiallyUnownedClassNotifyFieldCallback -> m (GClosure C_InitiallyUnownedClassNotifyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_InitiallyUnownedClassNotifyFieldCallback :: C_InitiallyUnownedClassNotifyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassNotifyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_InitiallyUnownedClassNotifyFieldCallback`.

noInitiallyUnownedClassNotifyFieldCallback :: Maybe InitiallyUnownedClassNotifyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `InitiallyUnownedClassNotifyFieldCallback``.

wrap_InitiallyUnownedClassNotifyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)) -> InitiallyUnownedClassNotifyFieldCallback -> C_InitiallyUnownedClassNotifyFieldCallback Source #

Wrap a `InitiallyUnownedClassNotifyFieldCallback` into a `C_InitiallyUnownedClassNotifyFieldCallback`.

## InitiallyUnownedClassSetPropertyFieldCallback

type C_InitiallyUnownedClassSetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassSetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_InitiallyUnownedClassSetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassSetPropertyFieldCallback :: MonadIO m => InitiallyUnownedClassSetPropertyFieldCallback -> m (GClosure C_InitiallyUnownedClassSetPropertyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_InitiallyUnownedClassSetPropertyFieldCallback :: C_InitiallyUnownedClassSetPropertyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_InitiallyUnownedClassSetPropertyFieldCallback`.

noInitiallyUnownedClassSetPropertyFieldCallback :: Maybe InitiallyUnownedClassSetPropertyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `InitiallyUnownedClassSetPropertyFieldCallback``.

wrap_InitiallyUnownedClassSetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)) -> InitiallyUnownedClassSetPropertyFieldCallback -> C_InitiallyUnownedClassSetPropertyFieldCallback Source #

Wrap a `InitiallyUnownedClassSetPropertyFieldCallback` into a `C_InitiallyUnownedClassSetPropertyFieldCallback`.

## InstanceInitFunc

type C_InstanceInitFunc = Ptr TypeInstance -> Ptr TypeClass -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InstanceInitFunc Source #

Arguments

= TypeInstance | `instance`: The instance to initialize
-> TypeClass | `gClass`: The class of the type the instance is created for
-> IO () |

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.

dynamic_InstanceInitFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_InstanceInitFunc |
-> TypeInstance | `instance`: The instance to initialize
-> TypeClass | `gClass`: The class of the type the instance is created for
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InstanceInitFunc :: MonadIO m => InstanceInitFunc -> m (GClosure C_InstanceInitFunc) Source #

Wrap the callback into a `GClosure`.

mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc) Source #

Generate a function pointer callable from C code, from a `C_InstanceInitFunc`.

noInstanceInitFunc :: Maybe InstanceInitFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `InstanceInitFunc``.

wrap_InstanceInitFunc :: Maybe (Ptr (FunPtr C_InstanceInitFunc)) -> InstanceInitFunc -> C_InstanceInitFunc Source #

Wrap a `InstanceInitFunc` into a `C_InstanceInitFunc`.

## InterfaceFinalizeFunc

type C_InterfaceFinalizeFunc = Ptr TypeInterface -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InterfaceFinalizeFunc Source #

Arguments

= TypeInterface | `gIface`: The interface structure to finalize
-> Ptr () | `ifaceData`: The `interfaceData` supplied via the `InterfaceInfo` structure
-> IO () |

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.

dynamic_InterfaceFinalizeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_InterfaceFinalizeFunc |
-> TypeInterface | `gIface`: The interface structure to finalize
-> Ptr () | `ifaceData`: The `interfaceData` supplied via the `InterfaceInfo` structure
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InterfaceFinalizeFunc :: MonadIO m => InterfaceFinalizeFunc -> m (GClosure C_InterfaceFinalizeFunc) Source #

Wrap the callback into a `GClosure`.

mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc) Source #

Generate a function pointer callable from C code, from a `C_InterfaceFinalizeFunc`.

noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `InterfaceFinalizeFunc``.

wrap_InterfaceFinalizeFunc :: Maybe (Ptr (FunPtr C_InterfaceFinalizeFunc)) -> InterfaceFinalizeFunc -> C_InterfaceFinalizeFunc Source #

Wrap a `InterfaceFinalizeFunc` into a `C_InterfaceFinalizeFunc`.

## InterfaceInitFunc

type C_InterfaceInitFunc = Ptr TypeInterface -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type InterfaceInitFunc Source #

Arguments

= TypeInterface | `gIface`: The interface structure to initialize
-> Ptr () | `ifaceData`: The `interfaceData` supplied via the `InterfaceInfo` structure
-> IO () |

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.

dynamic_InterfaceInitFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_InterfaceInitFunc |
-> TypeInterface | `gIface`: The interface structure to initialize
-> Ptr () | `ifaceData`: The `interfaceData` supplied via the `InterfaceInfo` structure
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InterfaceInitFunc :: MonadIO m => InterfaceInitFunc -> m (GClosure C_InterfaceInitFunc) Source #

Wrap the callback into a `GClosure`.

mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc) Source #

Generate a function pointer callable from C code, from a `C_InterfaceInitFunc`.

noInterfaceInitFunc :: Maybe InterfaceInitFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `InterfaceInitFunc``.

wrap_InterfaceInitFunc :: Maybe (Ptr (FunPtr C_InterfaceInitFunc)) -> InterfaceInitFunc -> C_InterfaceInitFunc Source #

Wrap a `InterfaceInitFunc` into a `C_InterfaceInitFunc`.

## ObjectClassConstructedFieldCallback

type C_ObjectClassConstructedFieldCallback = Ptr Object -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectClassConstructedFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassConstructedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassConstructedFieldCallback -> a -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassConstructedFieldCallback :: MonadIO m => ObjectClassConstructedFieldCallback -> m (GClosure C_ObjectClassConstructedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ObjectClassConstructedFieldCallback :: C_ObjectClassConstructedFieldCallback -> IO (FunPtr C_ObjectClassConstructedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ObjectClassConstructedFieldCallback`.

noObjectClassConstructedFieldCallback :: Maybe ObjectClassConstructedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectClassConstructedFieldCallback``.

wrap_ObjectClassConstructedFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassConstructedFieldCallback)) -> ObjectClassConstructedFieldCallback -> C_ObjectClassConstructedFieldCallback Source #

Wrap a `ObjectClassConstructedFieldCallback` into a `C_ObjectClassConstructedFieldCallback`.

## ObjectClassDispatchPropertiesChangedFieldCallback

type C_ObjectClassDispatchPropertiesChangedFieldCallback = Ptr Object -> Word32 -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectClassDispatchPropertiesChangedFieldCallback = Object -> Word32 -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassDispatchPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassDispatchPropertiesChangedFieldCallback :: MonadIO m => ObjectClassDispatchPropertiesChangedFieldCallback -> m (GClosure C_ObjectClassDispatchPropertiesChangedFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ObjectClassDispatchPropertiesChangedFieldCallback :: C_ObjectClassDispatchPropertiesChangedFieldCallback -> IO (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ObjectClassDispatchPropertiesChangedFieldCallback`.

noObjectClassDispatchPropertiesChangedFieldCallback :: Maybe ObjectClassDispatchPropertiesChangedFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectClassDispatchPropertiesChangedFieldCallback``.

wrap_ObjectClassDispatchPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)) -> ObjectClassDispatchPropertiesChangedFieldCallback -> C_ObjectClassDispatchPropertiesChangedFieldCallback Source #

Wrap a `ObjectClassDispatchPropertiesChangedFieldCallback` into a `C_ObjectClassDispatchPropertiesChangedFieldCallback`.

## ObjectClassDisposeFieldCallback

type C_ObjectClassDisposeFieldCallback = Ptr Object -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectClassDisposeFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassDisposeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassDisposeFieldCallback -> a -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassDisposeFieldCallback :: MonadIO m => ObjectClassDisposeFieldCallback -> m (GClosure C_ObjectClassDisposeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ObjectClassDisposeFieldCallback :: C_ObjectClassDisposeFieldCallback -> IO (FunPtr C_ObjectClassDisposeFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ObjectClassDisposeFieldCallback`.

noObjectClassDisposeFieldCallback :: Maybe ObjectClassDisposeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectClassDisposeFieldCallback``.

wrap_ObjectClassDisposeFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDisposeFieldCallback)) -> ObjectClassDisposeFieldCallback -> C_ObjectClassDisposeFieldCallback Source #

Wrap a `ObjectClassDisposeFieldCallback` into a `C_ObjectClassDisposeFieldCallback`.

## ObjectClassFinalizeFieldCallback

type C_ObjectClassFinalizeFieldCallback = Ptr Object -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectClassFinalizeFieldCallback = Object -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassFinalizeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassFinalizeFieldCallback -> a -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassFinalizeFieldCallback :: MonadIO m => ObjectClassFinalizeFieldCallback -> m (GClosure C_ObjectClassFinalizeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ObjectClassFinalizeFieldCallback :: C_ObjectClassFinalizeFieldCallback -> IO (FunPtr C_ObjectClassFinalizeFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ObjectClassFinalizeFieldCallback`.

noObjectClassFinalizeFieldCallback :: Maybe ObjectClassFinalizeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectClassFinalizeFieldCallback``.

wrap_ObjectClassFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassFinalizeFieldCallback)) -> ObjectClassFinalizeFieldCallback -> C_ObjectClassFinalizeFieldCallback Source #

Wrap a `ObjectClassFinalizeFieldCallback` into a `C_ObjectClassFinalizeFieldCallback`.

## ObjectClassGetPropertyFieldCallback

type C_ObjectClassGetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectClassGetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassGetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassGetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassGetPropertyFieldCallback :: MonadIO m => ObjectClassGetPropertyFieldCallback -> m (GClosure C_ObjectClassGetPropertyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ObjectClassGetPropertyFieldCallback :: C_ObjectClassGetPropertyFieldCallback -> IO (FunPtr C_ObjectClassGetPropertyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ObjectClassGetPropertyFieldCallback`.

noObjectClassGetPropertyFieldCallback :: Maybe ObjectClassGetPropertyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectClassGetPropertyFieldCallback``.

wrap_ObjectClassGetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassGetPropertyFieldCallback)) -> ObjectClassGetPropertyFieldCallback -> C_ObjectClassGetPropertyFieldCallback Source #

Wrap a `ObjectClassGetPropertyFieldCallback` into a `C_ObjectClassGetPropertyFieldCallback`.

## ObjectClassNotifyFieldCallback

type C_ObjectClassNotifyFieldCallback = Ptr Object -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectClassNotifyFieldCallback Source #

Arguments

= Object | `object`: a `Object`
-> GParamSpec |
-> IO () |

No description available in the introspection data.

dynamic_ObjectClassNotifyFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) |
=> FunPtr C_ObjectClassNotifyFieldCallback |
-> a | `object`: a `Object`
-> GParamSpec |
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassNotifyFieldCallback :: MonadIO m => ObjectClassNotifyFieldCallback -> m (GClosure C_ObjectClassNotifyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ObjectClassNotifyFieldCallback :: C_ObjectClassNotifyFieldCallback -> IO (FunPtr C_ObjectClassNotifyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ObjectClassNotifyFieldCallback`.

noObjectClassNotifyFieldCallback :: Maybe ObjectClassNotifyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectClassNotifyFieldCallback``.

wrap_ObjectClassNotifyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassNotifyFieldCallback)) -> ObjectClassNotifyFieldCallback -> C_ObjectClassNotifyFieldCallback Source #

Wrap a `ObjectClassNotifyFieldCallback` into a `C_ObjectClassNotifyFieldCallback`.

## ObjectClassSetPropertyFieldCallback

type C_ObjectClassSetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectClassSetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_ObjectClassSetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassSetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassSetPropertyFieldCallback :: MonadIO m => ObjectClassSetPropertyFieldCallback -> m (GClosure C_ObjectClassSetPropertyFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ObjectClassSetPropertyFieldCallback :: C_ObjectClassSetPropertyFieldCallback -> IO (FunPtr C_ObjectClassSetPropertyFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ObjectClassSetPropertyFieldCallback`.

noObjectClassSetPropertyFieldCallback :: Maybe ObjectClassSetPropertyFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectClassSetPropertyFieldCallback``.

wrap_ObjectClassSetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)) -> ObjectClassSetPropertyFieldCallback -> C_ObjectClassSetPropertyFieldCallback Source #

Wrap a `ObjectClassSetPropertyFieldCallback` into a `C_ObjectClassSetPropertyFieldCallback`.

## ObjectFinalizeFunc

type C_ObjectFinalizeFunc = Ptr Object -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectFinalizeFunc Source #

Arguments

= Object | `object`: the `Object` being finalized
-> IO () |

The type of the `finalize` function of `ObjectClass`.

dynamic_ObjectFinalizeFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) |
=> FunPtr C_ObjectFinalizeFunc |
-> a | `object`: the `Object` being finalized
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectFinalizeFunc :: MonadIO m => ObjectFinalizeFunc -> m (GClosure C_ObjectFinalizeFunc) Source #

Wrap the callback into a `GClosure`.

mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc) Source #

Generate a function pointer callable from C code, from a `C_ObjectFinalizeFunc`.

noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectFinalizeFunc``.

wrap_ObjectFinalizeFunc :: Maybe (Ptr (FunPtr C_ObjectFinalizeFunc)) -> ObjectFinalizeFunc -> C_ObjectFinalizeFunc Source #

Wrap a `ObjectFinalizeFunc` into a `C_ObjectFinalizeFunc`.

## ObjectGetPropertyFunc

type C_ObjectGetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectGetPropertyFunc Source #

Arguments

= Object | `object`: a `Object`
-> Word32 | `propertyId`: the numeric id under which the property was registered with `objectClassInstallProperty`.
-> GValue | `value`: a `Value` to return the property value in
-> GParamSpec | `pspec`: the `ParamSpec` describing the property
-> IO () |

The type of the `getProperty` function of `ObjectClass`.

dynamic_ObjectGetPropertyFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) |
=> FunPtr C_ObjectGetPropertyFunc |
-> a | `object`: a `Object`
-> Word32 | `propertyId`: the numeric id under which the property was registered with `objectClassInstallProperty`.
-> GValue | `value`: a `Value` to return the property value in
-> GParamSpec | `pspec`: the `ParamSpec` describing the property
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectGetPropertyFunc :: MonadIO m => ObjectGetPropertyFunc -> m (GClosure C_ObjectGetPropertyFunc) Source #

Wrap the callback into a `GClosure`.

mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc) Source #

Generate a function pointer callable from C code, from a `C_ObjectGetPropertyFunc`.

noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectGetPropertyFunc``.

wrap_ObjectGetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectGetPropertyFunc)) -> ObjectGetPropertyFunc -> C_ObjectGetPropertyFunc Source #

Wrap a `ObjectGetPropertyFunc` into a `C_ObjectGetPropertyFunc`.

## ObjectSetPropertyFunc

type C_ObjectSetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ObjectSetPropertyFunc Source #

Arguments

= Object | `object`: a `Object`
-> Word32 | `propertyId`: the numeric id under which the property was registered with `objectClassInstallProperty`.
-> GValue | `value`: the new value for the property
-> GParamSpec | `pspec`: the `ParamSpec` describing the property
-> IO () |

The type of the `setProperty` function of `ObjectClass`.

dynamic_ObjectSetPropertyFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) |
=> FunPtr C_ObjectSetPropertyFunc |
-> a | `object`: a `Object`
-> Word32 | `propertyId`: the numeric id under which the property was registered with `objectClassInstallProperty`.
-> GValue | `value`: the new value for the property
-> GParamSpec | `pspec`: the `ParamSpec` describing the property
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectSetPropertyFunc :: MonadIO m => ObjectSetPropertyFunc -> m (GClosure C_ObjectSetPropertyFunc) Source #

Wrap the callback into a `GClosure`.

mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc) Source #

Generate a function pointer callable from C code, from a `C_ObjectSetPropertyFunc`.

noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `ObjectSetPropertyFunc``.

wrap_ObjectSetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) -> ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc Source #

Wrap a `ObjectSetPropertyFunc` into a `C_ObjectSetPropertyFunc`.

## ParamSpecTypeInfoFinalizeFieldCallback

type C_ParamSpecTypeInfoFinalizeFieldCallback = Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ParamSpecTypeInfoFinalizeFieldCallback = GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_ParamSpecTypeInfoFinalizeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> GParamSpec -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: MonadIO m => ParamSpecTypeInfoFinalizeFieldCallback -> m (GClosure C_ParamSpecTypeInfoFinalizeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoFinalizeFieldCallback`.

noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ParamSpecTypeInfoFinalizeFieldCallback``.

wrap_ParamSpecTypeInfoFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)) -> ParamSpecTypeInfoFinalizeFieldCallback -> C_ParamSpecTypeInfoFinalizeFieldCallback Source #

Wrap a `ParamSpecTypeInfoFinalizeFieldCallback` into a `C_ParamSpecTypeInfoFinalizeFieldCallback`.

## ParamSpecTypeInfoInstanceInitFieldCallback

type C_ParamSpecTypeInfoInstanceInitFieldCallback = Ptr GParamSpec -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ParamSpecTypeInfoInstanceInitFieldCallback = GParamSpec -> IO () Source #

No description available in the introspection data.

dynamic_ParamSpecTypeInfoInstanceInitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> GParamSpec -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: MonadIO m => ParamSpecTypeInfoInstanceInitFieldCallback -> m (GClosure C_ParamSpecTypeInfoInstanceInitFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoInstanceInitFieldCallback`.

noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ParamSpecTypeInfoInstanceInitFieldCallback``.

wrap_ParamSpecTypeInfoInstanceInitFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)) -> ParamSpecTypeInfoInstanceInitFieldCallback -> C_ParamSpecTypeInfoInstanceInitFieldCallback Source #

Wrap a `ParamSpecTypeInfoInstanceInitFieldCallback` into a `C_ParamSpecTypeInfoInstanceInitFieldCallback`.

## ParamSpecTypeInfoValueSetDefaultFieldCallback

type C_ParamSpecTypeInfoValueSetDefaultFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ParamSpecTypeInfoValueSetDefaultFieldCallback = GParamSpec -> GValue -> IO () Source #

No description available in the introspection data.

dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> GParamSpec -> GValue -> m () Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: MonadIO m => ParamSpecTypeInfoValueSetDefaultFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueSetDefaultFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoValueSetDefaultFieldCallback`.

noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ParamSpecTypeInfoValueSetDefaultFieldCallback``.

wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)) -> ParamSpecTypeInfoValueSetDefaultFieldCallback -> C_ParamSpecTypeInfoValueSetDefaultFieldCallback Source #

Wrap a `ParamSpecTypeInfoValueSetDefaultFieldCallback` into a `C_ParamSpecTypeInfoValueSetDefaultFieldCallback`.

## ParamSpecTypeInfoValueValidateFieldCallback

type C_ParamSpecTypeInfoValueValidateFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO CInt Source #

Type for the callback on the (unwrapped) C side.

type ParamSpecTypeInfoValueValidateFieldCallback = GParamSpec -> GValue -> IO Bool Source #

No description available in the introspection data.

dynamic_ParamSpecTypeInfoValueValidateFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> GParamSpec -> GValue -> m Bool Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: MonadIO m => ParamSpecTypeInfoValueValidateFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueValidateFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoValueValidateFieldCallback`.

noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ParamSpecTypeInfoValueValidateFieldCallback``.

wrap_ParamSpecTypeInfoValueValidateFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)) -> ParamSpecTypeInfoValueValidateFieldCallback -> C_ParamSpecTypeInfoValueValidateFieldCallback Source #

Wrap a `ParamSpecTypeInfoValueValidateFieldCallback` into a `C_ParamSpecTypeInfoValueValidateFieldCallback`.

## ParamSpecTypeInfoValuesCmpFieldCallback

type C_ParamSpecTypeInfoValuesCmpFieldCallback = Ptr GParamSpec -> Ptr GValue -> Ptr GValue -> IO Int32 Source #

Type for the callback on the (unwrapped) C side.

type ParamSpecTypeInfoValuesCmpFieldCallback = GParamSpec -> GValue -> GValue -> IO Int32 Source #

No description available in the introspection data.

dynamic_ParamSpecTypeInfoValuesCmpFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> GParamSpec -> GValue -> GValue -> m Int32 Source #

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: MonadIO m => ParamSpecTypeInfoValuesCmpFieldCallback -> m (GClosure C_ParamSpecTypeInfoValuesCmpFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback) Source #

Generate a function pointer callable from C code, from a `C_ParamSpecTypeInfoValuesCmpFieldCallback`.

noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback Source #

A convenience synonym for ``Nothing` :: `Maybe` `ParamSpecTypeInfoValuesCmpFieldCallback``.

wrap_ParamSpecTypeInfoValuesCmpFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)) -> ParamSpecTypeInfoValuesCmpFieldCallback -> C_ParamSpecTypeInfoValuesCmpFieldCallback Source #

Wrap a `ParamSpecTypeInfoValuesCmpFieldCallback` into a `C_ParamSpecTypeInfoValuesCmpFieldCallback`.

## SignalAccumulator

type C_SignalAccumulator = Ptr SignalInvocationHint -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt Source #

Type for the callback on the (unwrapped) C side.

type SignalAccumulator Source #

Arguments

= SignalInvocationHint | `ihint`: Signal invocation hint, see `SignalInvocationHint`.
-> GValue | `returnAccu`: Accumulator to collect callback return values in, this is the return value of the current signal emission.
-> GValue | `handlerReturn`: A `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 `True` will continue with the signal emission. Returning `False` will abort the current emission. Since 2.62, returning `False` will skip to the CLEANUP stage. In this case, emission will occur as normal in the CLEANUP stage and the handler's return value will be accumulated.

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.

dynamic_SignalAccumulator Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_SignalAccumulator |
-> SignalInvocationHint | `ihint`: Signal invocation hint, see `SignalInvocationHint`.
-> GValue | `returnAccu`: Accumulator to collect callback return values in, this is the return value of the current signal emission.
-> GValue | `handlerReturn`: A `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 `True` will continue with the signal emission. Returning `False` will abort the current emission. Since 2.62, returning `False` will skip to the CLEANUP stage. In this case, emission will occur as normal in the CLEANUP stage and the handler's return value will be accumulated.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SignalAccumulator :: MonadIO m => SignalAccumulator -> m (GClosure C_SignalAccumulator) Source #

Wrap the callback into a `GClosure`.

mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator) Source #

Generate a function pointer callable from C code, from a `C_SignalAccumulator`.

noSignalAccumulator :: Maybe SignalAccumulator Source #

A convenience synonym for ``Nothing` :: `Maybe` `SignalAccumulator``.

wrap_SignalAccumulator :: Maybe (Ptr (FunPtr C_SignalAccumulator)) -> SignalAccumulator -> C_SignalAccumulator Source #

Wrap a `SignalAccumulator` into a `C_SignalAccumulator`.

## SignalEmissionHook

type C_SignalEmissionHook = Ptr SignalInvocationHint -> Word32 -> Ptr GValue -> Ptr () -> IO CInt Source #

Type for the callback on the (unwrapped) C side.

type SignalEmissionHook Source #

Arguments

= SignalInvocationHint | `ihint`: Signal invocation hint, see `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 simple function pointer to get invoked when the signal is emitted.

Emission hooks allow 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 `SignalFlagsNoHooks` flag.

dynamic_SignalEmissionHook Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_SignalEmissionHook |
-> SignalInvocationHint | `ihint`: Signal invocation hint, see `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).

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SignalEmissionHook :: MonadIO m => SignalEmissionHook -> m (GClosure C_SignalEmissionHook) Source #

Wrap the callback into a `GClosure`.

mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook) Source #

Generate a function pointer callable from C code, from a `C_SignalEmissionHook`.

noSignalEmissionHook :: Maybe SignalEmissionHook Source #

A convenience synonym for ``Nothing` :: `Maybe` `SignalEmissionHook``.

wrap_SignalEmissionHook :: Maybe (Ptr (FunPtr C_SignalEmissionHook)) -> SignalEmissionHook -> C_SignalEmissionHook Source #

Wrap a `SignalEmissionHook` into a `C_SignalEmissionHook`.

## ToggleNotify

type C_ToggleNotify = Ptr () -> Ptr Object -> CInt -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ToggleNotify Source #

Arguments

= Ptr () | `data`: Callback data passed to `g_object_add_toggle_ref()`
-> 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 callback function used for notification when the state of a toggle reference changes.

See also: `g_object_add_toggle_ref()`

dynamic_ToggleNotify Source #

Arguments

:: (HasCallStack, MonadIO m, 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 () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ToggleNotify :: MonadIO m => ToggleNotify -> m (GClosure C_ToggleNotify) Source #

Wrap the callback into a `GClosure`.

mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify) Source #

Generate a function pointer callable from C code, from a `C_ToggleNotify`.

noToggleNotify :: Maybe ToggleNotify Source #

A convenience synonym for ``Nothing` :: `Maybe` `ToggleNotify``.

wrap_ToggleNotify :: Maybe (Ptr (FunPtr C_ToggleNotify)) -> ToggleNotify -> C_ToggleNotify Source #

Wrap a `ToggleNotify` into a `C_ToggleNotify`.

## TypeClassCacheFunc

type C_TypeClassCacheFunc = Ptr () -> Ptr TypeClass -> IO CInt Source #

Type for the callback on the (unwrapped) C side.

type TypeClassCacheFunc Source #

Arguments

= Ptr () | `cacheData`: data that was given to the `g_type_add_class_cache_func()` call
-> TypeClass | `gClass`: The `TypeClass` structure which is unreferenced
-> IO Bool | Returns: `True` to stop further `GTypeClassCacheFuncs` from being called, `False` to continue

A callback function which is called when the reference count of a class drops to zero.

It may use `typeClassRef` to prevent the class from being freed. You should not call `typeClassUnref` from a `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 `TypeClassCacheFunc` chain.

dynamic_TypeClassCacheFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TypeClassCacheFunc |
-> Ptr () | `cacheData`: data that was given to the `g_type_add_class_cache_func()` call
-> TypeClass | `gClass`: The `TypeClass` structure which is unreferenced
-> m Bool | Returns: `True` to stop further `GTypeClassCacheFuncs` from being called, `False` to continue

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeClassCacheFunc :: MonadIO m => TypeClassCacheFunc -> m (GClosure C_TypeClassCacheFunc) Source #

Wrap the callback into a `GClosure`.

mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc) Source #

Generate a function pointer callable from C code, from a `C_TypeClassCacheFunc`.

noTypeClassCacheFunc :: Maybe TypeClassCacheFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypeClassCacheFunc``.

wrap_TypeClassCacheFunc :: Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) -> TypeClassCacheFunc -> C_TypeClassCacheFunc Source #

Wrap a `TypeClassCacheFunc` into a `C_TypeClassCacheFunc`.

## TypeInterfaceCheckFunc

type C_TypeInterfaceCheckFunc = Ptr () -> Ptr TypeInterface -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TypeInterfaceCheckFunc Source #

Arguments

= Ptr () | `checkData`: data passed to `g_type_add_interface_check()`
-> TypeInterface | `gIface`: the interface that has been initialized
-> IO () |

A callback called after an interface vtable is initialized.

See `g_type_add_interface_check()`.

Since: 2.4

dynamic_TypeInterfaceCheckFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TypeInterfaceCheckFunc |
-> Ptr () | `checkData`: data passed to `g_type_add_interface_check()`
-> TypeInterface | `gIface`: the interface that has been initialized
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeInterfaceCheckFunc :: MonadIO m => TypeInterfaceCheckFunc -> m (GClosure C_TypeInterfaceCheckFunc) Source #

Wrap the callback into a `GClosure`.

mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc) Source #

Generate a function pointer callable from C code, from a `C_TypeInterfaceCheckFunc`.

noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypeInterfaceCheckFunc``.

wrap_TypeInterfaceCheckFunc :: Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc)) -> TypeInterfaceCheckFunc -> C_TypeInterfaceCheckFunc Source #

Wrap a `TypeInterfaceCheckFunc` into a `C_TypeInterfaceCheckFunc`.

## TypePluginCompleteInterfaceInfo

type C_TypePluginCompleteInterfaceInfo = Ptr TypePlugin -> CGType -> CGType -> Ptr InterfaceInfo -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TypePluginCompleteInterfaceInfo Source #

Arguments

= TypePlugin | `plugin`: the `TypePlugin`
-> GType | `instanceType`: the `GType` of an instantiatable type to which the interface is added
-> GType | `interfaceType`: the `GType` of the interface whose info is completed
-> InterfaceInfo | `info`: the `InterfaceInfo` to fill in
-> IO () |

The type of the `completeInterfaceInfo` function of `GTypePluginClass`.

dynamic_TypePluginCompleteInterfaceInfo Source #

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a) |
=> FunPtr C_TypePluginCompleteInterfaceInfo |
-> a | `plugin`: the `TypePlugin`
-> GType | `instanceType`: the `GType` of an instantiatable type to which the interface is added
-> GType | `interfaceType`: the `GType` of the interface whose info is completed
-> InterfaceInfo | `info`: the `InterfaceInfo` to fill in
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypePluginCompleteInterfaceInfo :: MonadIO m => TypePluginCompleteInterfaceInfo -> m (GClosure C_TypePluginCompleteInterfaceInfo) Source #

Wrap the callback into a `GClosure`.

mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo) Source #

Generate a function pointer callable from C code, from a `C_TypePluginCompleteInterfaceInfo`.

noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypePluginCompleteInterfaceInfo``.

wrap_TypePluginCompleteInterfaceInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) -> TypePluginCompleteInterfaceInfo -> C_TypePluginCompleteInterfaceInfo Source #

Wrap a `TypePluginCompleteInterfaceInfo` into a `C_TypePluginCompleteInterfaceInfo`.

## TypePluginCompleteTypeInfo

type C_TypePluginCompleteTypeInfo = Ptr TypePlugin -> CGType -> Ptr TypeInfo -> Ptr TypeValueTable -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TypePluginCompleteTypeInfo Source #

Arguments

= TypePlugin | `plugin`: the `TypePlugin`
-> GType | `gType`: the `GType` whose info is completed
-> TypeInfo | `info`: the `TypeInfo` struct to fill in
-> TypeValueTable | `valueTable`: the `TypeValueTable` to fill in
-> IO () |

The type of the `completeTypeInfo` function of `GTypePluginClass`.

dynamic_TypePluginCompleteTypeInfo Source #

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a) |
=> FunPtr C_TypePluginCompleteTypeInfo |
-> a | `plugin`: the `TypePlugin`
-> GType | `gType`: the `GType` whose info is completed
-> TypeInfo | `info`: the `TypeInfo` struct to fill in
-> TypeValueTable | `valueTable`: the `TypeValueTable` to fill in
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypePluginCompleteTypeInfo :: MonadIO m => TypePluginCompleteTypeInfo -> m (GClosure C_TypePluginCompleteTypeInfo) Source #

Wrap the callback into a `GClosure`.

mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo) Source #

Generate a function pointer callable from C code, from a `C_TypePluginCompleteTypeInfo`.

noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypePluginCompleteTypeInfo``.

wrap_TypePluginCompleteTypeInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) -> TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo Source #

Wrap a `TypePluginCompleteTypeInfo` into a `C_TypePluginCompleteTypeInfo`.

## TypePluginUnuse

type C_TypePluginUnuse = Ptr TypePlugin -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TypePluginUnuse Source #

Arguments

= TypePlugin | `plugin`: the `TypePlugin` whose use count should be decreased
-> IO () |

The type of the `unusePlugin` function of `GTypePluginClass`.

dynamic_TypePluginUnuse Source #

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a) |
=> FunPtr C_TypePluginUnuse |
-> a | `plugin`: the `TypePlugin` whose use count should be decreased
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypePluginUnuse :: MonadIO m => TypePluginUnuse -> m (GClosure C_TypePluginUnuse) Source #

Wrap the callback into a `GClosure`.

mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse) Source #

Generate a function pointer callable from C code, from a `C_TypePluginUnuse`.

noTypePluginUnuse :: Maybe TypePluginUnuse Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypePluginUnuse``.

wrap_TypePluginUnuse :: Maybe (Ptr (FunPtr C_TypePluginUnuse)) -> TypePluginUnuse -> C_TypePluginUnuse Source #

Wrap a `TypePluginUnuse` into a `C_TypePluginUnuse`.

## TypePluginUse

type C_TypePluginUse = Ptr TypePlugin -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TypePluginUse Source #

Arguments

= TypePlugin | `plugin`: the `TypePlugin` whose use count should be increased
-> IO () |

The type of the `usePlugin` function of `GTypePluginClass`, which gets called to increase the use count of `plugin`.

dynamic_TypePluginUse Source #

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a) |
=> FunPtr C_TypePluginUse |
-> a | `plugin`: the `TypePlugin` whose use count should be increased
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypePluginUse :: MonadIO m => TypePluginUse -> m (GClosure C_TypePluginUse) Source #

Wrap the callback into a `GClosure`.

mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse) Source #

Generate a function pointer callable from C code, from a `C_TypePluginUse`.

noTypePluginUse :: Maybe TypePluginUse Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypePluginUse``.

wrap_TypePluginUse :: Maybe (Ptr (FunPtr C_TypePluginUse)) -> TypePluginUse -> C_TypePluginUse Source #

Wrap a `TypePluginUse` into a `C_TypePluginUse`.

## TypeValueCollectFunc

type C_TypeValueCollectFunc = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString Source #

Type for the callback on the (unwrapped) C side.

type TypeValueCollectFunc Source #

Arguments

= GValue | `value`: the value to initialize
-> [TypeCValue] | `collectValues`: the collected values
-> Word32 | `collectFlags`: optional flags
-> IO (Maybe Text) | Returns: `NULL` on success, otherwise a newly allocated error string on failure

This function is responsible for converting the values collected from a variadic argument list into contents suitable for storage in a `Value`.

This function should setup `value` similar to `TypeValueInitFunc`; e.g. for a string value that does not allow `NULL` pointers, it needs to either emit an error, or do an implicit conversion by storing an empty string.

The `value` passed in to this function has a zero-filled data array, so just like for `TypeValueInitFunc` it is guaranteed to not contain any old contents that might need freeing.

The `nCollectValues` argument is the string length of the `collect_format` field of `TypeValueTable`, and `collect_values` is an array of `TypeCValue` with length of `nCollectValues`, containing the collected values according to `collect_format`.

The `collectFlags` argument provided as a hint by the caller. It may contain the flag `VALUE_NOCOPY_CONTENTS` indicating that the collected value contents may be considered ‘static’ for the duration of the `value` lifetime. Thus an extra copy of the contents stored in `collectValues` is not required for assignment to `value`.

For our above string example, we continue with:

### C code

    if (!collect_values[0].v_pointer)
      value->data[0].v_pointer = g_strdup ("");
    else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
      {
        value->data[0].v_pointer = collect_values[0].v_pointer;
        // keep a flag for the value_free() implementation to not free this string
        value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
      }
    else
      value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
    return NULL;

It should be noted, that it is generally a bad idea to follow the `VALUE_NOCOPY_CONTENTS` hint for reference counted types. Due to reentrancy requirements and reference count assertions performed by the signal emission code, reference counts should always be incremented for reference counted contents stored in the `value->data` array. To deviate from our string example for a moment, and taking a look at an exemplary implementation for `GTypeValueTable.collect_value()` of `GObject`:

### C code

    GObject *object = G_OBJECT (collect_values[0].v_pointer);
    g_return_val_if_fail (object != NULL,
       g_strdup_printf ("Object %p passed as invalid NULL pointer", object));
    // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types
    value->data[0].v_pointer = g_object_ref (object);
    return NULL;

The reference count for valid objects is always incremented, regardless of `collect_flags`. For invalid objects, the example returns a newly allocated string without altering `value`.

Upon success, `collect_value()` needs to return `NULL`. If, however, an error condition occurred, `collect_value()` should return a newly allocated string containing an error diagnostic.

The calling code makes no assumptions about the `value` contents being valid upon error returns, `value` is simply thrown away without further freeing. As such, it is a good idea to not allocate `GValue` contents prior to returning an error; however, `collect_values()` is not obliged to return a correctly setup `value` for error returns, simply because any non-`NULL` return is considered a fatal programming error, and further program behaviour is undefined.

Since: 2.78

dynamic_TypeValueCollectFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TypeValueCollectFunc |
-> GValue | `value`: the value to initialize
-> [TypeCValue] | `collectValues`: the collected values
-> Word32 | `collectFlags`: optional flags
-> m (Maybe Text) | Returns: `NULL` on success, otherwise a newly allocated error string on failure

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueCollectFunc :: MonadIO m => TypeValueCollectFunc -> m (GClosure C_TypeValueCollectFunc) Source #

Wrap the callback into a `GClosure`.

mk_TypeValueCollectFunc :: C_TypeValueCollectFunc -> IO (FunPtr C_TypeValueCollectFunc) Source #

Generate a function pointer callable from C code, from a `C_TypeValueCollectFunc`.

noTypeValueCollectFunc :: Maybe TypeValueCollectFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypeValueCollectFunc``.

wrap_TypeValueCollectFunc :: Maybe (Ptr (FunPtr C_TypeValueCollectFunc)) -> TypeValueCollectFunc -> C_TypeValueCollectFunc Source #

Wrap a `TypeValueCollectFunc` into a `C_TypeValueCollectFunc`.

## TypeValueCopyFunc

type C_TypeValueCopyFunc = Ptr GValue -> Ptr GValue -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TypeValueCopyFunc Source #

Arguments

= GValue | `srcValue`: the value to copy
-> IO GValue |

Copies the content of a `Value` into another.

The `destValue` is a `Value` with zero-filled data section and `srcValue` is a properly initialized `Value` of same type, or derived type.

The purpose of this function is to copy the contents of `srcValue` into `destValue` in a way, that even after `srcValue` has been freed, the contents of `destValue` remain valid. String type example:

### C code

    dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);

Since: 2.78

dynamic_TypeValueCopyFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TypeValueCopyFunc |
-> GValue | `srcValue`: the value to copy
-> m GValue |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueCopyFunc :: MonadIO m => TypeValueCopyFunc -> m (GClosure C_TypeValueCopyFunc) Source #

Wrap the callback into a `GClosure`.

mk_TypeValueCopyFunc :: C_TypeValueCopyFunc -> IO (FunPtr C_TypeValueCopyFunc) Source #

Generate a function pointer callable from C code, from a `C_TypeValueCopyFunc`.

noTypeValueCopyFunc :: Maybe TypeValueCopyFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypeValueCopyFunc``.

wrap_TypeValueCopyFunc :: Maybe (Ptr (FunPtr C_TypeValueCopyFunc)) -> TypeValueCopyFunc -> C_TypeValueCopyFunc Source #

Wrap a `TypeValueCopyFunc` into a `C_TypeValueCopyFunc`.

## TypeValueFreeFunc

type C_TypeValueFreeFunc = Ptr GValue -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TypeValueFreeFunc Source #

Arguments

= GValue | `value`: the value to free
-> IO () |

Frees any old contents that might be left in the `value->data` array of the given value.

No resources may remain allocated through the `Value` contents after this function returns. E.g. for our above string type:

### C code

    // only free strings without a specific flag for static storage
    if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
      g_free (value->data[0].v_pointer);

Since: 2.78

dynamic_TypeValueFreeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TypeValueFreeFunc |
-> GValue | `value`: the value to free
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueFreeFunc :: MonadIO m => TypeValueFreeFunc -> m (GClosure C_TypeValueFreeFunc) Source #

Wrap the callback into a `GClosure`.

mk_TypeValueFreeFunc :: C_TypeValueFreeFunc -> IO (FunPtr C_TypeValueFreeFunc) Source #

Generate a function pointer callable from C code, from a `C_TypeValueFreeFunc`.

noTypeValueFreeFunc :: Maybe TypeValueFreeFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypeValueFreeFunc``.

wrap_TypeValueFreeFunc :: Maybe (Ptr (FunPtr C_TypeValueFreeFunc)) -> TypeValueFreeFunc -> C_TypeValueFreeFunc Source #

Wrap a `TypeValueFreeFunc` into a `C_TypeValueFreeFunc`.

## TypeValueInitFunc

type C_TypeValueInitFunc = Ptr GValue -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TypeValueInitFunc Source #

Arguments

= GValue | `value`: the value to initialize
-> IO () |

Initializes the value contents by setting the fields of the `value->data` array.

The data array of the `Value` passed into this function was zero-filled with `memset()`, so no care has to be taken to free any old contents. For example, in the case of a string value that may never be `Nothing`, the implementation might look like:

### C code

    value->data[0].v_pointer = g_strdup ("");

Since: 2.78

dynamic_TypeValueInitFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TypeValueInitFunc |
-> GValue | `value`: the value to initialize
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueInitFunc :: MonadIO m => TypeValueInitFunc -> m (GClosure C_TypeValueInitFunc) Source #

Wrap the callback into a `GClosure`.

mk_TypeValueInitFunc :: C_TypeValueInitFunc -> IO (FunPtr C_TypeValueInitFunc) Source #

Generate a function pointer callable from C code, from a `C_TypeValueInitFunc`.

noTypeValueInitFunc :: Maybe TypeValueInitFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypeValueInitFunc``.

wrap_TypeValueInitFunc :: Maybe (Ptr (FunPtr C_TypeValueInitFunc)) -> TypeValueInitFunc -> C_TypeValueInitFunc Source #

Wrap a `TypeValueInitFunc` into a `C_TypeValueInitFunc`.

## TypeValueLCopyFunc

type C_TypeValueLCopyFunc = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString Source #

Type for the callback on the (unwrapped) C side.

type TypeValueLCopyFunc Source #

Arguments

= GValue | `value`: the value to lcopy
-> [TypeCValue] | `collectValues`: the collected locations for storage
-> Word32 | `collectFlags`: optional flags
-> IO (Maybe Text) | Returns: `NULL` on success, otherwise a newly allocated error string on failure

This function is responsible for storing the `value` contents into arguments passed through a variadic argument list which got collected into `collect_values` according to `lcopy_format`.

The `n_collect_values` argument equals the string length of `lcopy_format`, and `collect_flags` may contain `VALUE_NOCOPY_CONTENTS`.

In contrast to `TypeValueCollectFunc`, this function is obliged to always properly support `VALUE_NOCOPY_CONTENTS`.

Similar to `TypeValueCollectFunc` the function may prematurely abort by returning a newly allocated string describing an error condition. To complete the string example:

### C code

    gchar **string_p = collect_values[0].v_pointer;
    g_return_val_if_fail (string_p != NULL,
      g_strdup ("string location passed as NULL"));

    if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
      *string_p = value->data[0].v_pointer;
    else
      *string_p = g_strdup (value->data[0].v_pointer);

And an illustrative version of this function for reference-counted types:

### C code

    GObject **object_p = collect_values[0].v_pointer;
    g_return_val_if_fail (object_p != NULL,
      g_strdup ("object location passed as NULL"));

    if (value->data[0].v_pointer == NULL)
      *object_p = NULL;
    else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour
      *object_p = value->data[0].v_pointer;
    else
      *object_p = g_object_ref (value->data[0].v_pointer);

    return NULL;

Since: 2.78

dynamic_TypeValueLCopyFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TypeValueLCopyFunc |
-> GValue | `value`: the value to lcopy
-> [TypeCValue] | `collectValues`: the collected locations for storage
-> Word32 | `collectFlags`: optional flags
-> m (Maybe Text) | Returns: `NULL` on success, otherwise a newly allocated error string on failure

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueLCopyFunc :: MonadIO m => TypeValueLCopyFunc -> m (GClosure C_TypeValueLCopyFunc) Source #

Wrap the callback into a `GClosure`.

mk_TypeValueLCopyFunc :: C_TypeValueLCopyFunc -> IO (FunPtr C_TypeValueLCopyFunc) Source #

Generate a function pointer callable from C code, from a `C_TypeValueLCopyFunc`.

noTypeValueLCopyFunc :: Maybe TypeValueLCopyFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypeValueLCopyFunc``.

wrap_TypeValueLCopyFunc :: Maybe (Ptr (FunPtr C_TypeValueLCopyFunc)) -> TypeValueLCopyFunc -> C_TypeValueLCopyFunc Source #

Wrap a `TypeValueLCopyFunc` into a `C_TypeValueLCopyFunc`.

## TypeValuePeekPointerFunc

type C_TypeValuePeekPointerFunc = Ptr GValue -> IO (Ptr ()) Source #

Type for the callback on the (unwrapped) C side.

type TypeValuePeekPointerFunc Source #

Arguments

= GValue | `value`: the value to peek
-> IO (Ptr ()) | Returns: a pointer to the value contents

If the value contents fit into a pointer, such as objects or strings, return this pointer, so the caller can peek at the current contents.

To extend on our above string example:

### C code

    return value->data[0].v_pointer;

Since: 2.78

dynamic_TypeValuePeekPointerFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TypeValuePeekPointerFunc |
-> GValue | `value`: the value to peek
-> m (Ptr ()) | Returns: a pointer to the value contents

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValuePeekPointerFunc :: MonadIO m => TypeValuePeekPointerFunc -> m (GClosure C_TypeValuePeekPointerFunc) Source #

Wrap the callback into a `GClosure`.

mk_TypeValuePeekPointerFunc :: C_TypeValuePeekPointerFunc -> IO (FunPtr C_TypeValuePeekPointerFunc) Source #

Generate a function pointer callable from C code, from a `C_TypeValuePeekPointerFunc`.

noTypeValuePeekPointerFunc :: Maybe TypeValuePeekPointerFunc Source #

A convenience synonym for ``Nothing` :: `Maybe` `TypeValuePeekPointerFunc``.

wrap_TypeValuePeekPointerFunc :: Maybe (Ptr (FunPtr C_TypeValuePeekPointerFunc)) -> TypeValuePeekPointerFunc -> C_TypeValuePeekPointerFunc Source #

Wrap a `TypeValuePeekPointerFunc` into a `C_TypeValuePeekPointerFunc`.

## ValueTransform

type C_ValueTransform = Ptr GValue -> Ptr GValue -> IO () Source #

Type for the callback on the (unwrapped) C side.

type ValueTransform Source #

Arguments

= GValue | `srcValue`: source value
-> GValue | `destValue`: target value
-> IO () |

The type of value transformation functions which can be registered with `Value`.`register_transform_func`().

`destValue` will be initialized to the correct destination type.

dynamic_ValueTransform Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ValueTransform |
-> GValue | `srcValue`: source value
-> GValue | `destValue`: target value
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ValueTransform :: MonadIO m => ValueTransform -> m (GClosure C_ValueTransform) Source #

Wrap the callback into a `GClosure`.

mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform) Source #

Generate a function pointer callable from C code, from a `C_ValueTransform`.

noValueTransform :: Maybe ValueTransform Source #

A convenience synonym for ``Nothing` :: `Maybe` `ValueTransform``.

wrap_ValueTransform :: Maybe (Ptr (FunPtr C_ValueTransform)) -> ValueTransform -> C_ValueTransform Source #

Wrap a `ValueTransform` into a `C_ValueTransform`.

## WeakNotify

type C_WeakNotify = Ptr () -> Ptr Object -> IO () Source #

Type for the callback on the (unwrapped) C side.

type WeakNotify Source #

Arguments

= Ptr () | `data`: data that was provided when the weak reference was established
-> Object | `whereTheObjectWas`: the object being disposed
-> IO () |

A `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 disposed when the `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.

In particular, this means it’s invalid to call `objectRef`, `g_weak_ref_init()`, `g_weak_ref_set()`, `g_object_add_toggle_ref()`, `g_object_weak_ref()`, `g_object_add_weak_pointer()` or any function which calls them on the object from this callback.

dynamic_WeakNotify Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a) |
=> FunPtr C_WeakNotify |
-> Ptr () | `data`: data that was provided when the weak reference was established
-> a | `whereTheObjectWas`: the object being disposed
-> m () |

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_WeakNotify :: MonadIO m => WeakNotify -> m (GClosure C_WeakNotify) Source #

Wrap the callback into a `GClosure`.

mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify) Source #

Generate a function pointer callable from C code, from a `C_WeakNotify`.

noWeakNotify :: Maybe WeakNotify Source #

A convenience synonym for ``Nothing` :: `Maybe` `WeakNotify``.

wrap_WeakNotify :: Maybe (Ptr (FunPtr C_WeakNotify)) -> WeakNotify -> C_WeakNotify Source #

Wrap a `WeakNotify` into a `C_WeakNotify`.