gi-glib-2.0.29: GLib bindings

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

GI.GLib.Callbacks

Contents

- Signals
  - CacheDestroyFunc
  - CacheDupFunc
  - CacheNewFunc
  - ChildWatchFunc
  - ClearHandleFunc
  - CompareDataFunc
  - CompareFunc
  - CompletionFunc
  - CompletionStrncmpFunc
  - CopyFunc
  - DataForeachFunc
  - DestroyNotify
  - DuplicateFunc
  - EqualFunc
  - EqualFuncFull
  - ErrorClearFunc
  - ErrorCopyFunc
  - ErrorInitFunc
  - FreeFunc
  - Func
  - HFunc
  - HRFunc
  - HashFunc
  - HookCheckFunc
  - HookCheckMarshaller
  - HookCompareFunc
  - HookFinalizeFunc
  - HookFindFunc
  - HookFunc
  - HookMarshaller
  - IOFunc
  - IOFuncsIoCloseFieldCallback
  - IOFuncsIoCreateWatchFieldCallback
  - IOFuncsIoFreeFieldCallback
  - IOFuncsIoGetFlagsFieldCallback
  - IOFuncsIoReadFieldCallback
  - IOFuncsIoSeekFieldCallback
  - IOFuncsIoSetFlagsFieldCallback
  - IOFuncsIoWriteFieldCallback
  - LogFunc
  - LogWriterFunc
  - MarkupParserEndElementFieldCallback
  - MarkupParserErrorFieldCallback
  - MarkupParserPassthroughFieldCallback
  - MarkupParserStartElementFieldCallback
  - MarkupParserTextFieldCallback
  - MemVTableCallocFieldCallback
  - MemVTableFreeFieldCallback
  - MemVTableMallocFieldCallback
  - MemVTableReallocFieldCallback
  - MemVTableTryMallocFieldCallback
  - MemVTableTryReallocFieldCallback
  - NodeForeachFunc
  - NodeTraverseFunc
  - OptionArgFunc
  - OptionErrorFunc
  - OptionParseFunc
  - PollFunc
  - PrintFunc
  - RegexEvalCallback
  - ScannerMsgFunc
  - SequenceIterCompareFunc
  - SourceCallbackFuncsRefFieldCallback
  - SourceCallbackFuncsUnrefFieldCallback
  - SourceDisposeFunc
  - SourceDummyMarshal
  - SourceFunc
  - SourceFuncsCheckFieldCallback
  - SourceFuncsFinalizeFieldCallback
  - SourceFuncsPrepareFieldCallback
  - SourceOnceFunc
  - SpawnChildSetupFunc
  - TestDataFunc
  - TestFixtureFunc
  - TestFunc
  - TestLogFatalFunc
  - ThreadFunc
  - TranslateFunc
  - TraverseFunc
  - TraverseNodeFunc
  - UnixFDSourceFunc
  - VoidFunc

Description

Synopsis

- type C_CacheDestroyFunc = Ptr () -> IO ()
- type CacheDestroyFunc = IO ()
- type CacheDestroyFunc_WithClosures = Ptr () -> IO ()
- drop_closures_CacheDestroyFunc :: CacheDestroyFunc -> CacheDestroyFunc_WithClosures
- dynamic_CacheDestroyFunc :: (HasCallStack, MonadIO m) => FunPtr C_CacheDestroyFunc -> Ptr () -> m ()
- genClosure_CacheDestroyFunc :: MonadIO m => CacheDestroyFunc -> m (GClosure C_CacheDestroyFunc)
- mk_CacheDestroyFunc :: C_CacheDestroyFunc -> IO (FunPtr C_CacheDestroyFunc)
- noCacheDestroyFunc :: Maybe CacheDestroyFunc
- noCacheDestroyFunc_WithClosures :: Maybe CacheDestroyFunc_WithClosures
- wrap_CacheDestroyFunc :: Maybe (Ptr (FunPtr C_CacheDestroyFunc)) -> CacheDestroyFunc_WithClosures -> C_CacheDestroyFunc
- type C_CacheDupFunc = Ptr () -> IO (Ptr ())
- type CacheDupFunc = IO (Ptr ())
- type CacheDupFunc_WithClosures = Ptr () -> IO (Ptr ())
- drop_closures_CacheDupFunc :: CacheDupFunc -> CacheDupFunc_WithClosures
- dynamic_CacheDupFunc :: (HasCallStack, MonadIO m) => FunPtr C_CacheDupFunc -> Ptr () -> m (Ptr ())
- genClosure_CacheDupFunc :: MonadIO m => CacheDupFunc -> m (GClosure C_CacheDupFunc)
- mk_CacheDupFunc :: C_CacheDupFunc -> IO (FunPtr C_CacheDupFunc)
- noCacheDupFunc :: Maybe CacheDupFunc
- noCacheDupFunc_WithClosures :: Maybe CacheDupFunc_WithClosures
- wrap_CacheDupFunc :: Maybe (Ptr (FunPtr C_CacheDupFunc)) -> CacheDupFunc_WithClosures -> C_CacheDupFunc
- type C_CacheNewFunc = Ptr () -> IO (Ptr ())
- type CacheNewFunc = IO (Ptr ())
- type CacheNewFunc_WithClosures = Ptr () -> IO (Ptr ())
- drop_closures_CacheNewFunc :: CacheNewFunc -> CacheNewFunc_WithClosures
- dynamic_CacheNewFunc :: (HasCallStack, MonadIO m) => FunPtr C_CacheNewFunc -> Ptr () -> m (Ptr ())
- genClosure_CacheNewFunc :: MonadIO m => CacheNewFunc -> m (GClosure C_CacheNewFunc)
- mk_CacheNewFunc :: C_CacheNewFunc -> IO (FunPtr C_CacheNewFunc)
- noCacheNewFunc :: Maybe CacheNewFunc
- noCacheNewFunc_WithClosures :: Maybe CacheNewFunc_WithClosures
- wrap_CacheNewFunc :: Maybe (Ptr (FunPtr C_CacheNewFunc)) -> CacheNewFunc_WithClosures -> C_CacheNewFunc
- type C_ChildWatchFunc = Int32 -> Int32 -> Ptr () -> IO ()
- type ChildWatchFunc = Int32 -> Int32 -> IO ()
- type ChildWatchFunc_WithClosures = Int32 -> Int32 -> Ptr () -> IO ()
- drop_closures_ChildWatchFunc :: ChildWatchFunc -> ChildWatchFunc_WithClosures
- dynamic_ChildWatchFunc :: (HasCallStack, MonadIO m) => FunPtr C_ChildWatchFunc -> Int32 -> Int32 -> Ptr () -> m ()
- genClosure_ChildWatchFunc :: MonadIO m => ChildWatchFunc -> m (GClosure C_ChildWatchFunc)
- mk_ChildWatchFunc :: C_ChildWatchFunc -> IO (FunPtr C_ChildWatchFunc)
- noChildWatchFunc :: Maybe ChildWatchFunc
- noChildWatchFunc_WithClosures :: Maybe ChildWatchFunc_WithClosures
- wrap_ChildWatchFunc :: Maybe (Ptr (FunPtr C_ChildWatchFunc)) -> ChildWatchFunc_WithClosures -> C_ChildWatchFunc
- type C_ClearHandleFunc = Word32 -> IO ()
- type ClearHandleFunc = Word32 -> IO ()
- dynamic_ClearHandleFunc :: (HasCallStack, MonadIO m) => FunPtr C_ClearHandleFunc -> Word32 -> m ()
- genClosure_ClearHandleFunc :: MonadIO m => ClearHandleFunc -> m (GClosure C_ClearHandleFunc)
- mk_ClearHandleFunc :: C_ClearHandleFunc -> IO (FunPtr C_ClearHandleFunc)
- noClearHandleFunc :: Maybe ClearHandleFunc
- wrap_ClearHandleFunc :: Maybe (Ptr (FunPtr C_ClearHandleFunc)) -> ClearHandleFunc -> C_ClearHandleFunc
- type C_CompareDataFunc = Ptr () -> Ptr () -> Ptr () -> IO Int32
- type CompareDataFunc = Ptr () -> Ptr () -> IO Int32
- type CompareDataFunc_WithClosures = Ptr () -> Ptr () -> Ptr () -> IO Int32
- drop_closures_CompareDataFunc :: CompareDataFunc -> CompareDataFunc_WithClosures
- dynamic_CompareDataFunc :: (HasCallStack, MonadIO m) => FunPtr C_CompareDataFunc -> Ptr () -> Ptr () -> Ptr () -> m Int32
- genClosure_CompareDataFunc :: MonadIO m => CompareDataFunc -> m (GClosure C_CompareDataFunc)
- mk_CompareDataFunc :: C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
- noCompareDataFunc :: Maybe CompareDataFunc
- noCompareDataFunc_WithClosures :: Maybe CompareDataFunc_WithClosures
- wrap_CompareDataFunc :: Maybe (Ptr (FunPtr C_CompareDataFunc)) -> CompareDataFunc_WithClosures -> C_CompareDataFunc
- type C_CompareFunc = Ptr () -> Ptr () -> IO Int32
- type CompareFunc = Ptr () -> IO Int32
- type CompareFunc_WithClosures = Ptr () -> Ptr () -> IO Int32
- drop_closures_CompareFunc :: CompareFunc -> CompareFunc_WithClosures
- dynamic_CompareFunc :: (HasCallStack, MonadIO m) => FunPtr C_CompareFunc -> Ptr () -> Ptr () -> m Int32
- genClosure_CompareFunc :: MonadIO m => CompareFunc -> m (GClosure C_CompareFunc)
- mk_CompareFunc :: C_CompareFunc -> IO (FunPtr C_CompareFunc)
- noCompareFunc :: Maybe CompareFunc
- noCompareFunc_WithClosures :: Maybe CompareFunc_WithClosures
- wrap_CompareFunc :: Maybe (Ptr (FunPtr C_CompareFunc)) -> CompareFunc_WithClosures -> C_CompareFunc
- type C_CompletionFunc = Ptr () -> IO CString
- type CompletionFunc = IO Text
- type CompletionFunc_WithClosures = Ptr () -> IO Text
- drop_closures_CompletionFunc :: CompletionFunc -> CompletionFunc_WithClosures
- dynamic_CompletionFunc :: (HasCallStack, MonadIO m) => FunPtr C_CompletionFunc -> Ptr () -> m Text
- genClosure_CompletionFunc :: MonadIO m => CompletionFunc -> m (GClosure C_CompletionFunc)
- mk_CompletionFunc :: C_CompletionFunc -> IO (FunPtr C_CompletionFunc)
- noCompletionFunc :: Maybe CompletionFunc
- noCompletionFunc_WithClosures :: Maybe CompletionFunc_WithClosures
- wrap_CompletionFunc :: Maybe (Ptr (FunPtr C_CompletionFunc)) -> CompletionFunc_WithClosures -> C_CompletionFunc
- type C_CompletionStrncmpFunc = CString -> CString -> Word64 -> IO Int32
- type CompletionStrncmpFunc = Text -> Text -> Word64 -> IO Int32
- dynamic_CompletionStrncmpFunc :: (HasCallStack, MonadIO m) => FunPtr C_CompletionStrncmpFunc -> Text -> Text -> Word64 -> m Int32
- genClosure_CompletionStrncmpFunc :: MonadIO m => CompletionStrncmpFunc -> m (GClosure C_CompletionStrncmpFunc)
- mk_CompletionStrncmpFunc :: C_CompletionStrncmpFunc -> IO (FunPtr C_CompletionStrncmpFunc)
- noCompletionStrncmpFunc :: Maybe CompletionStrncmpFunc
- wrap_CompletionStrncmpFunc :: Maybe (Ptr (FunPtr C_CompletionStrncmpFunc)) -> CompletionStrncmpFunc -> C_CompletionStrncmpFunc
- type C_CopyFunc = Ptr () -> Ptr () -> IO (Ptr ())
- type CopyFunc = Ptr () -> IO (Ptr ())
- type CopyFunc_WithClosures = Ptr () -> Ptr () -> IO (Ptr ())
- drop_closures_CopyFunc :: CopyFunc -> CopyFunc_WithClosures
- dynamic_CopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_CopyFunc -> Ptr () -> Ptr () -> m (Ptr ())
- genClosure_CopyFunc :: MonadIO m => CopyFunc -> m (GClosure C_CopyFunc)
- mk_CopyFunc :: C_CopyFunc -> IO (FunPtr C_CopyFunc)
- noCopyFunc :: Maybe CopyFunc
- noCopyFunc_WithClosures :: Maybe CopyFunc_WithClosures
- wrap_CopyFunc :: Maybe (Ptr (FunPtr C_CopyFunc)) -> CopyFunc_WithClosures -> C_CopyFunc
- type C_DataForeachFunc = Word32 -> Ptr () -> Ptr () -> IO ()
- type DataForeachFunc = Word32 -> Ptr () -> IO ()
- type DataForeachFunc_WithClosures = Word32 -> Ptr () -> Ptr () -> IO ()
- drop_closures_DataForeachFunc :: DataForeachFunc -> DataForeachFunc_WithClosures
- dynamic_DataForeachFunc :: (HasCallStack, MonadIO m) => FunPtr C_DataForeachFunc -> Word32 -> Ptr () -> Ptr () -> m ()
- genClosure_DataForeachFunc :: MonadIO m => DataForeachFunc -> m (GClosure C_DataForeachFunc)
- mk_DataForeachFunc :: C_DataForeachFunc -> IO (FunPtr C_DataForeachFunc)
- noDataForeachFunc :: Maybe DataForeachFunc
- noDataForeachFunc_WithClosures :: Maybe DataForeachFunc_WithClosures
- wrap_DataForeachFunc :: Maybe (Ptr (FunPtr C_DataForeachFunc)) -> DataForeachFunc_WithClosures -> C_DataForeachFunc
- type C_DestroyNotify = Ptr () -> IO ()
- type DestroyNotify = IO ()
- type DestroyNotify_WithClosures = Ptr () -> IO ()
- drop_closures_DestroyNotify :: DestroyNotify -> DestroyNotify_WithClosures
- dynamic_DestroyNotify :: (HasCallStack, MonadIO m) => FunPtr C_DestroyNotify -> Ptr () -> m ()
- genClosure_DestroyNotify :: MonadIO m => DestroyNotify -> m (GClosure C_DestroyNotify)
- mk_DestroyNotify :: C_DestroyNotify -> IO (FunPtr C_DestroyNotify)
- noDestroyNotify :: Maybe DestroyNotify
- noDestroyNotify_WithClosures :: Maybe DestroyNotify_WithClosures
- wrap_DestroyNotify :: Maybe (Ptr (FunPtr C_DestroyNotify)) -> DestroyNotify_WithClosures -> C_DestroyNotify
- type C_DuplicateFunc = Ptr () -> Ptr () -> IO (Ptr ())
- type DuplicateFunc = Ptr () -> IO (Ptr ())
- type DuplicateFunc_WithClosures = Ptr () -> Ptr () -> IO (Ptr ())
- drop_closures_DuplicateFunc :: DuplicateFunc -> DuplicateFunc_WithClosures
- dynamic_DuplicateFunc :: (HasCallStack, MonadIO m) => FunPtr C_DuplicateFunc -> Ptr () -> Ptr () -> m (Ptr ())
- genClosure_DuplicateFunc :: MonadIO m => DuplicateFunc -> m (GClosure C_DuplicateFunc)
- mk_DuplicateFunc :: C_DuplicateFunc -> IO (FunPtr C_DuplicateFunc)
- noDuplicateFunc :: Maybe DuplicateFunc
- noDuplicateFunc_WithClosures :: Maybe DuplicateFunc_WithClosures
- wrap_DuplicateFunc :: Maybe (Ptr (FunPtr C_DuplicateFunc)) -> DuplicateFunc_WithClosures -> C_DuplicateFunc
- type C_EqualFunc = Ptr () -> Ptr () -> IO CInt
- type EqualFunc = Ptr () -> IO Bool
- type EqualFunc_WithClosures = Ptr () -> Ptr () -> IO Bool
- drop_closures_EqualFunc :: EqualFunc -> EqualFunc_WithClosures
- dynamic_EqualFunc :: (HasCallStack, MonadIO m) => FunPtr C_EqualFunc -> Ptr () -> Ptr () -> m Bool
- genClosure_EqualFunc :: MonadIO m => EqualFunc -> m (GClosure C_EqualFunc)
- mk_EqualFunc :: C_EqualFunc -> IO (FunPtr C_EqualFunc)
- noEqualFunc :: Maybe EqualFunc
- noEqualFunc_WithClosures :: Maybe EqualFunc_WithClosures
- wrap_EqualFunc :: Maybe (Ptr (FunPtr C_EqualFunc)) -> EqualFunc_WithClosures -> C_EqualFunc
- type C_EqualFuncFull = Ptr () -> Ptr () -> Ptr () -> IO CInt
- type EqualFuncFull = Ptr () -> Ptr () -> IO Bool
- type EqualFuncFull_WithClosures = Ptr () -> Ptr () -> Ptr () -> IO Bool
- drop_closures_EqualFuncFull :: EqualFuncFull -> EqualFuncFull_WithClosures
- dynamic_EqualFuncFull :: (HasCallStack, MonadIO m) => FunPtr C_EqualFuncFull -> Ptr () -> Ptr () -> Ptr () -> m Bool
- genClosure_EqualFuncFull :: MonadIO m => EqualFuncFull -> m (GClosure C_EqualFuncFull)
- mk_EqualFuncFull :: C_EqualFuncFull -> IO (FunPtr C_EqualFuncFull)
- noEqualFuncFull :: Maybe EqualFuncFull
- noEqualFuncFull_WithClosures :: Maybe EqualFuncFull_WithClosures
- wrap_EqualFuncFull :: Maybe (Ptr (FunPtr C_EqualFuncFull)) -> EqualFuncFull_WithClosures -> C_EqualFuncFull
- type C_ErrorClearFunc = Ptr GError -> IO ()
- type ErrorClearFunc = GError -> IO ()
- dynamic_ErrorClearFunc :: (HasCallStack, MonadIO m) => FunPtr C_ErrorClearFunc -> GError -> m ()
- genClosure_ErrorClearFunc :: MonadIO m => ErrorClearFunc -> m (GClosure C_ErrorClearFunc)
- mk_ErrorClearFunc :: C_ErrorClearFunc -> IO (FunPtr C_ErrorClearFunc)
- noErrorClearFunc :: Maybe ErrorClearFunc
- wrap_ErrorClearFunc :: Maybe (Ptr (FunPtr C_ErrorClearFunc)) -> ErrorClearFunc -> C_ErrorClearFunc
- type C_ErrorCopyFunc = Ptr GError -> Ptr GError -> IO ()
- type ErrorCopyFunc = GError -> GError -> IO ()
- dynamic_ErrorCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_ErrorCopyFunc -> GError -> GError -> m ()
- genClosure_ErrorCopyFunc :: MonadIO m => ErrorCopyFunc -> m (GClosure C_ErrorCopyFunc)
- mk_ErrorCopyFunc :: C_ErrorCopyFunc -> IO (FunPtr C_ErrorCopyFunc)
- noErrorCopyFunc :: Maybe ErrorCopyFunc
- wrap_ErrorCopyFunc :: Maybe (Ptr (FunPtr C_ErrorCopyFunc)) -> ErrorCopyFunc -> C_ErrorCopyFunc
- type C_ErrorInitFunc = Ptr GError -> IO ()
- type ErrorInitFunc = GError -> IO ()
- dynamic_ErrorInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_ErrorInitFunc -> GError -> m ()
- genClosure_ErrorInitFunc :: MonadIO m => ErrorInitFunc -> m (GClosure C_ErrorInitFunc)
- mk_ErrorInitFunc :: C_ErrorInitFunc -> IO (FunPtr C_ErrorInitFunc)
- noErrorInitFunc :: Maybe ErrorInitFunc
- wrap_ErrorInitFunc :: Maybe (Ptr (FunPtr C_ErrorInitFunc)) -> ErrorInitFunc -> C_ErrorInitFunc
- type C_FreeFunc = Ptr () -> IO ()
- type FreeFunc = IO ()
- type FreeFunc_WithClosures = Ptr () -> IO ()
- drop_closures_FreeFunc :: FreeFunc -> FreeFunc_WithClosures
- dynamic_FreeFunc :: (HasCallStack, MonadIO m) => FunPtr C_FreeFunc -> Ptr () -> m ()
- genClosure_FreeFunc :: MonadIO m => FreeFunc -> m (GClosure C_FreeFunc)
- mk_FreeFunc :: C_FreeFunc -> IO (FunPtr C_FreeFunc)
- noFreeFunc :: Maybe FreeFunc
- noFreeFunc_WithClosures :: Maybe FreeFunc_WithClosures
- wrap_FreeFunc :: Maybe (Ptr (FunPtr C_FreeFunc)) -> FreeFunc_WithClosures -> C_FreeFunc
- type C_Func = Ptr () -> Ptr () -> IO ()
- type Func = Ptr () -> IO ()
- type Func_WithClosures = Ptr () -> Ptr () -> IO ()
- drop_closures_Func :: Func -> Func_WithClosures
- dynamic_Func :: (HasCallStack, MonadIO m) => FunPtr C_Func -> Ptr () -> Ptr () -> m ()
- genClosure_Func :: MonadIO m => Func -> m (GClosure C_Func)
- mk_Func :: C_Func -> IO (FunPtr C_Func)
- noFunc :: Maybe Func
- noFunc_WithClosures :: Maybe Func_WithClosures
- wrap_Func :: Maybe (Ptr (FunPtr C_Func)) -> Func_WithClosures -> C_Func
- type C_HFunc = Ptr () -> Ptr () -> Ptr () -> IO ()
- type HFunc = Ptr () -> Ptr () -> IO ()
- type HFunc_WithClosures = Ptr () -> Ptr () -> Ptr () -> IO ()
- drop_closures_HFunc :: HFunc -> HFunc_WithClosures
- dynamic_HFunc :: (HasCallStack, MonadIO m) => FunPtr C_HFunc -> Ptr () -> Ptr () -> Ptr () -> m ()
- genClosure_HFunc :: MonadIO m => HFunc -> m (GClosure C_HFunc)
- mk_HFunc :: C_HFunc -> IO (FunPtr C_HFunc)
- noHFunc :: Maybe HFunc
- noHFunc_WithClosures :: Maybe HFunc_WithClosures
- wrap_HFunc :: Maybe (Ptr (FunPtr C_HFunc)) -> HFunc_WithClosures -> C_HFunc
- type C_HRFunc = Ptr () -> Ptr () -> Ptr () -> IO CInt
- type HRFunc = Ptr () -> Ptr () -> IO Bool
- type HRFunc_WithClosures = Ptr () -> Ptr () -> Ptr () -> IO Bool
- drop_closures_HRFunc :: HRFunc -> HRFunc_WithClosures
- dynamic_HRFunc :: (HasCallStack, MonadIO m) => FunPtr C_HRFunc -> Ptr () -> Ptr () -> Ptr () -> m Bool
- genClosure_HRFunc :: MonadIO m => HRFunc -> m (GClosure C_HRFunc)
- mk_HRFunc :: C_HRFunc -> IO (FunPtr C_HRFunc)
- noHRFunc :: Maybe HRFunc
- noHRFunc_WithClosures :: Maybe HRFunc_WithClosures
- wrap_HRFunc :: Maybe (Ptr (FunPtr C_HRFunc)) -> HRFunc_WithClosures -> C_HRFunc
- type C_HashFunc = Ptr () -> IO Word32
- type HashFunc = IO Word32
- type HashFunc_WithClosures = Ptr () -> IO Word32
- drop_closures_HashFunc :: HashFunc -> HashFunc_WithClosures
- dynamic_HashFunc :: (HasCallStack, MonadIO m) => FunPtr C_HashFunc -> Ptr () -> m Word32
- genClosure_HashFunc :: MonadIO m => HashFunc -> m (GClosure C_HashFunc)
- mk_HashFunc :: C_HashFunc -> IO (FunPtr C_HashFunc)
- noHashFunc :: Maybe HashFunc
- noHashFunc_WithClosures :: Maybe HashFunc_WithClosures
- wrap_HashFunc :: Maybe (Ptr (FunPtr C_HashFunc)) -> HashFunc_WithClosures -> C_HashFunc
- type C_HookCheckFunc = Ptr () -> IO CInt
- type HookCheckFunc = IO Bool
- type HookCheckFunc_WithClosures = Ptr () -> IO Bool
- drop_closures_HookCheckFunc :: HookCheckFunc -> HookCheckFunc_WithClosures
- dynamic_HookCheckFunc :: (HasCallStack, MonadIO m) => FunPtr C_HookCheckFunc -> Ptr () -> m Bool
- genClosure_HookCheckFunc :: MonadIO m => HookCheckFunc -> m (GClosure C_HookCheckFunc)
- mk_HookCheckFunc :: C_HookCheckFunc -> IO (FunPtr C_HookCheckFunc)
- noHookCheckFunc :: Maybe HookCheckFunc
- noHookCheckFunc_WithClosures :: Maybe HookCheckFunc_WithClosures
- wrap_HookCheckFunc :: Maybe (Ptr (FunPtr C_HookCheckFunc)) -> HookCheckFunc_WithClosures -> C_HookCheckFunc
- type C_HookCheckMarshaller = Ptr Hook -> Ptr () -> IO CInt
- type HookCheckMarshaller = Hook -> IO Bool
- type HookCheckMarshaller_WithClosures = Hook -> Ptr () -> IO Bool
- drop_closures_HookCheckMarshaller :: HookCheckMarshaller -> HookCheckMarshaller_WithClosures
- dynamic_HookCheckMarshaller :: (HasCallStack, MonadIO m) => FunPtr C_HookCheckMarshaller -> Hook -> Ptr () -> m Bool
- genClosure_HookCheckMarshaller :: MonadIO m => HookCheckMarshaller -> m (GClosure C_HookCheckMarshaller)
- mk_HookCheckMarshaller :: C_HookCheckMarshaller -> IO (FunPtr C_HookCheckMarshaller)
- noHookCheckMarshaller :: Maybe HookCheckMarshaller
- noHookCheckMarshaller_WithClosures :: Maybe HookCheckMarshaller_WithClosures
- wrap_HookCheckMarshaller :: Maybe (Ptr (FunPtr C_HookCheckMarshaller)) -> HookCheckMarshaller_WithClosures -> C_HookCheckMarshaller
- type C_HookCompareFunc = Ptr Hook -> Ptr Hook -> IO Int32
- type HookCompareFunc = Hook -> Hook -> IO Int32
- dynamic_HookCompareFunc :: (HasCallStack, MonadIO m) => FunPtr C_HookCompareFunc -> Hook -> Hook -> m Int32
- genClosure_HookCompareFunc :: MonadIO m => HookCompareFunc -> m (GClosure C_HookCompareFunc)
- mk_HookCompareFunc :: C_HookCompareFunc -> IO (FunPtr C_HookCompareFunc)
- noHookCompareFunc :: Maybe HookCompareFunc
- wrap_HookCompareFunc :: Maybe (Ptr (FunPtr C_HookCompareFunc)) -> HookCompareFunc -> C_HookCompareFunc
- type C_HookFinalizeFunc = Ptr HookList -> Ptr Hook -> IO ()
- type HookFinalizeFunc = HookList -> Hook -> IO ()
- dynamic_HookFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_HookFinalizeFunc -> HookList -> Hook -> m ()
- genClosure_HookFinalizeFunc :: MonadIO m => HookFinalizeFunc -> m (GClosure C_HookFinalizeFunc)
- mk_HookFinalizeFunc :: C_HookFinalizeFunc -> IO (FunPtr C_HookFinalizeFunc)
- noHookFinalizeFunc :: Maybe HookFinalizeFunc
- wrap_HookFinalizeFunc :: Maybe (Ptr (FunPtr C_HookFinalizeFunc)) -> HookFinalizeFunc -> C_HookFinalizeFunc
- type C_HookFindFunc = Ptr Hook -> Ptr () -> IO CInt
- type HookFindFunc = Hook -> IO Bool
- type HookFindFunc_WithClosures = Hook -> Ptr () -> IO Bool
- drop_closures_HookFindFunc :: HookFindFunc -> HookFindFunc_WithClosures
- dynamic_HookFindFunc :: (HasCallStack, MonadIO m) => FunPtr C_HookFindFunc -> Hook -> Ptr () -> m Bool
- genClosure_HookFindFunc :: MonadIO m => HookFindFunc -> m (GClosure C_HookFindFunc)
- mk_HookFindFunc :: C_HookFindFunc -> IO (FunPtr C_HookFindFunc)
- noHookFindFunc :: Maybe HookFindFunc
- noHookFindFunc_WithClosures :: Maybe HookFindFunc_WithClosures
- wrap_HookFindFunc :: Maybe (Ptr (FunPtr C_HookFindFunc)) -> HookFindFunc_WithClosures -> C_HookFindFunc
- type C_HookFunc = Ptr () -> IO ()
- type HookFunc = IO ()
- type HookFunc_WithClosures = Ptr () -> IO ()
- drop_closures_HookFunc :: HookFunc -> HookFunc_WithClosures
- dynamic_HookFunc :: (HasCallStack, MonadIO m) => FunPtr C_HookFunc -> Ptr () -> m ()
- genClosure_HookFunc :: MonadIO m => HookFunc -> m (GClosure C_HookFunc)
- mk_HookFunc :: C_HookFunc -> IO (FunPtr C_HookFunc)
- noHookFunc :: Maybe HookFunc
- noHookFunc_WithClosures :: Maybe HookFunc_WithClosures
- wrap_HookFunc :: Maybe (Ptr (FunPtr C_HookFunc)) -> HookFunc_WithClosures -> C_HookFunc
- type C_HookMarshaller = Ptr Hook -> Ptr () -> IO ()
- type HookMarshaller = Hook -> IO ()
- type HookMarshaller_WithClosures = Hook -> Ptr () -> IO ()
- drop_closures_HookMarshaller :: HookMarshaller -> HookMarshaller_WithClosures
- dynamic_HookMarshaller :: (HasCallStack, MonadIO m) => FunPtr C_HookMarshaller -> Hook -> Ptr () -> m ()
- genClosure_HookMarshaller :: MonadIO m => HookMarshaller -> m (GClosure C_HookMarshaller)
- mk_HookMarshaller :: C_HookMarshaller -> IO (FunPtr C_HookMarshaller)
- noHookMarshaller :: Maybe HookMarshaller
- noHookMarshaller_WithClosures :: Maybe HookMarshaller_WithClosures
- wrap_HookMarshaller :: Maybe (Ptr (FunPtr C_HookMarshaller)) -> HookMarshaller_WithClosures -> C_HookMarshaller
- type C_IOFunc = Ptr IOChannel -> CUInt -> Ptr () -> IO CInt
- type IOFunc = IOChannel -> [IOCondition] -> IO Bool
- type IOFunc_WithClosures = IOChannel -> [IOCondition] -> Ptr () -> IO Bool
- drop_closures_IOFunc :: IOFunc -> IOFunc_WithClosures
- dynamic_IOFunc :: (HasCallStack, MonadIO m) => FunPtr C_IOFunc -> IOChannel -> [IOCondition] -> Ptr () -> m Bool
- genClosure_IOFunc :: MonadIO m => IOFunc -> m (GClosure C_IOFunc)
- mk_IOFunc :: C_IOFunc -> IO (FunPtr C_IOFunc)
- noIOFunc :: Maybe IOFunc
- noIOFunc_WithClosures :: Maybe IOFunc_WithClosures
- wrap_IOFunc :: Maybe (Ptr (FunPtr C_IOFunc)) -> IOFunc_WithClosures -> C_IOFunc
- type C_IOFuncsIoCloseFieldCallback = Ptr IOChannel -> Ptr (Ptr GError) -> IO CUInt
- type IOFuncsIoCloseFieldCallback = IOChannel -> IO IOStatus
- dynamic_IOFuncsIoCloseFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoCloseFieldCallback -> IOChannel -> m IOStatus
- mk_IOFuncsIoCloseFieldCallback :: C_IOFuncsIoCloseFieldCallback -> IO (FunPtr C_IOFuncsIoCloseFieldCallback)
- noIOFuncsIoCloseFieldCallback :: Maybe IOFuncsIoCloseFieldCallback
- type C_IOFuncsIoCreateWatchFieldCallback = Ptr IOChannel -> CUInt -> IO (Ptr Source)
- type IOFuncsIoCreateWatchFieldCallback = IOChannel -> [IOCondition] -> IO Source
- dynamic_IOFuncsIoCreateWatchFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoCreateWatchFieldCallback -> IOChannel -> [IOCondition] -> m Source
- genClosure_IOFuncsIoCreateWatchFieldCallback :: MonadIO m => IOFuncsIoCreateWatchFieldCallback -> m (GClosure C_IOFuncsIoCreateWatchFieldCallback)
- mk_IOFuncsIoCreateWatchFieldCallback :: C_IOFuncsIoCreateWatchFieldCallback -> IO (FunPtr C_IOFuncsIoCreateWatchFieldCallback)
- noIOFuncsIoCreateWatchFieldCallback :: Maybe IOFuncsIoCreateWatchFieldCallback
- wrap_IOFuncsIoCreateWatchFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)) -> IOFuncsIoCreateWatchFieldCallback -> C_IOFuncsIoCreateWatchFieldCallback
- type C_IOFuncsIoFreeFieldCallback = Ptr IOChannel -> IO ()
- type IOFuncsIoFreeFieldCallback = IOChannel -> IO ()
- dynamic_IOFuncsIoFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoFreeFieldCallback -> IOChannel -> m ()
- genClosure_IOFuncsIoFreeFieldCallback :: MonadIO m => IOFuncsIoFreeFieldCallback -> m (GClosure C_IOFuncsIoFreeFieldCallback)
- mk_IOFuncsIoFreeFieldCallback :: C_IOFuncsIoFreeFieldCallback -> IO (FunPtr C_IOFuncsIoFreeFieldCallback)
- noIOFuncsIoFreeFieldCallback :: Maybe IOFuncsIoFreeFieldCallback
- wrap_IOFuncsIoFreeFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)) -> IOFuncsIoFreeFieldCallback -> C_IOFuncsIoFreeFieldCallback
- type C_IOFuncsIoGetFlagsFieldCallback = Ptr IOChannel -> IO CUInt
- type IOFuncsIoGetFlagsFieldCallback = IOChannel -> IO [IOFlags]
- dynamic_IOFuncsIoGetFlagsFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoGetFlagsFieldCallback -> IOChannel -> m [IOFlags]
- genClosure_IOFuncsIoGetFlagsFieldCallback :: MonadIO m => IOFuncsIoGetFlagsFieldCallback -> m (GClosure C_IOFuncsIoGetFlagsFieldCallback)
- mk_IOFuncsIoGetFlagsFieldCallback :: C_IOFuncsIoGetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoGetFlagsFieldCallback)
- noIOFuncsIoGetFlagsFieldCallback :: Maybe IOFuncsIoGetFlagsFieldCallback
- wrap_IOFuncsIoGetFlagsFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)) -> IOFuncsIoGetFlagsFieldCallback -> C_IOFuncsIoGetFlagsFieldCallback
- type C_IOFuncsIoReadFieldCallback = Ptr IOChannel -> CString -> Word64 -> Word64 -> Ptr (Ptr GError) -> IO CUInt
- type IOFuncsIoReadFieldCallback = IOChannel -> Text -> Word64 -> Word64 -> IO IOStatus
- dynamic_IOFuncsIoReadFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoReadFieldCallback -> IOChannel -> Text -> Word64 -> Word64 -> m IOStatus
- mk_IOFuncsIoReadFieldCallback :: C_IOFuncsIoReadFieldCallback -> IO (FunPtr C_IOFuncsIoReadFieldCallback)
- noIOFuncsIoReadFieldCallback :: Maybe IOFuncsIoReadFieldCallback
- type C_IOFuncsIoSeekFieldCallback = Ptr IOChannel -> Int64 -> CUInt -> Ptr (Ptr GError) -> IO CUInt
- type IOFuncsIoSeekFieldCallback = IOChannel -> Int64 -> SeekType -> IO IOStatus
- dynamic_IOFuncsIoSeekFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoSeekFieldCallback -> IOChannel -> Int64 -> SeekType -> m IOStatus
- mk_IOFuncsIoSeekFieldCallback :: C_IOFuncsIoSeekFieldCallback -> IO (FunPtr C_IOFuncsIoSeekFieldCallback)
- noIOFuncsIoSeekFieldCallback :: Maybe IOFuncsIoSeekFieldCallback
- type C_IOFuncsIoSetFlagsFieldCallback = Ptr IOChannel -> CUInt -> Ptr (Ptr GError) -> IO CUInt
- type IOFuncsIoSetFlagsFieldCallback = IOChannel -> [IOFlags] -> IO IOStatus
- dynamic_IOFuncsIoSetFlagsFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoSetFlagsFieldCallback -> IOChannel -> [IOFlags] -> m IOStatus
- mk_IOFuncsIoSetFlagsFieldCallback :: C_IOFuncsIoSetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoSetFlagsFieldCallback)
- noIOFuncsIoSetFlagsFieldCallback :: Maybe IOFuncsIoSetFlagsFieldCallback
- type C_IOFuncsIoWriteFieldCallback = Ptr IOChannel -> CString -> Word64 -> Word64 -> Ptr (Ptr GError) -> IO CUInt
- type IOFuncsIoWriteFieldCallback = IOChannel -> Text -> Word64 -> Word64 -> IO IOStatus
- dynamic_IOFuncsIoWriteFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoWriteFieldCallback -> IOChannel -> Text -> Word64 -> Word64 -> m IOStatus
- mk_IOFuncsIoWriteFieldCallback :: C_IOFuncsIoWriteFieldCallback -> IO (FunPtr C_IOFuncsIoWriteFieldCallback)
- noIOFuncsIoWriteFieldCallback :: Maybe IOFuncsIoWriteFieldCallback
- type C_LogFunc = CString -> CInt -> CString -> Ptr () -> IO ()
- type LogFunc = Text -> [LogLevelFlags] -> Text -> IO ()
- type LogFunc_WithClosures = Text -> [LogLevelFlags] -> Text -> Ptr () -> IO ()
- drop_closures_LogFunc :: LogFunc -> LogFunc_WithClosures
- dynamic_LogFunc :: (HasCallStack, MonadIO m) => FunPtr C_LogFunc -> Text -> [LogLevelFlags] -> Text -> Ptr () -> m ()
- genClosure_LogFunc :: MonadIO m => LogFunc -> m (GClosure C_LogFunc)
- mk_LogFunc :: C_LogFunc -> IO (FunPtr C_LogFunc)
- noLogFunc :: Maybe LogFunc
- noLogFunc_WithClosures :: Maybe LogFunc_WithClosures
- wrap_LogFunc :: Maybe (Ptr (FunPtr C_LogFunc)) -> LogFunc_WithClosures -> C_LogFunc
- type C_LogWriterFunc = CInt -> Ptr LogField -> Word64 -> Ptr () -> IO CUInt
- type LogWriterFunc = [LogLevelFlags] -> [LogField] -> IO LogWriterOutput
- type LogWriterFunc_WithClosures = [LogLevelFlags] -> [LogField] -> Ptr () -> IO LogWriterOutput
- drop_closures_LogWriterFunc :: LogWriterFunc -> LogWriterFunc_WithClosures
- dynamic_LogWriterFunc :: (HasCallStack, MonadIO m) => FunPtr C_LogWriterFunc -> [LogLevelFlags] -> [LogField] -> Ptr () -> m LogWriterOutput
- genClosure_LogWriterFunc :: MonadIO m => LogWriterFunc -> m (GClosure C_LogWriterFunc)
- mk_LogWriterFunc :: C_LogWriterFunc -> IO (FunPtr C_LogWriterFunc)
- noLogWriterFunc :: Maybe LogWriterFunc
- noLogWriterFunc_WithClosures :: Maybe LogWriterFunc_WithClosures
- wrap_LogWriterFunc :: Maybe (Ptr (FunPtr C_LogWriterFunc)) -> LogWriterFunc_WithClosures -> C_LogWriterFunc
- type C_MarkupParserEndElementFieldCallback = Ptr MarkupParseContext -> CString -> Ptr () -> Ptr (Ptr GError) -> IO ()
- type MarkupParserEndElementFieldCallback = MarkupParseContext -> Text -> IO ()
- type MarkupParserEndElementFieldCallback_WithClosures = MarkupParseContext -> Text -> Ptr () -> IO ()
- drop_closures_MarkupParserEndElementFieldCallback :: MarkupParserEndElementFieldCallback -> MarkupParserEndElementFieldCallback_WithClosures
- dynamic_MarkupParserEndElementFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MarkupParserEndElementFieldCallback -> MarkupParseContext -> Text -> Ptr () -> m ()
- mk_MarkupParserEndElementFieldCallback :: C_MarkupParserEndElementFieldCallback -> IO (FunPtr C_MarkupParserEndElementFieldCallback)
- noMarkupParserEndElementFieldCallback :: Maybe MarkupParserEndElementFieldCallback
- noMarkupParserEndElementFieldCallback_WithClosures :: Maybe MarkupParserEndElementFieldCallback_WithClosures
- type C_MarkupParserErrorFieldCallback = Ptr MarkupParseContext -> Ptr GError -> Ptr () -> IO ()
- type MarkupParserErrorFieldCallback = MarkupParseContext -> GError -> IO ()
- type MarkupParserErrorFieldCallback_WithClosures = MarkupParseContext -> GError -> Ptr () -> IO ()
- drop_closures_MarkupParserErrorFieldCallback :: MarkupParserErrorFieldCallback -> MarkupParserErrorFieldCallback_WithClosures
- dynamic_MarkupParserErrorFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MarkupParserErrorFieldCallback -> MarkupParseContext -> GError -> Ptr () -> m ()
- genClosure_MarkupParserErrorFieldCallback :: MonadIO m => MarkupParserErrorFieldCallback -> m (GClosure C_MarkupParserErrorFieldCallback)
- mk_MarkupParserErrorFieldCallback :: C_MarkupParserErrorFieldCallback -> IO (FunPtr C_MarkupParserErrorFieldCallback)
- noMarkupParserErrorFieldCallback :: Maybe MarkupParserErrorFieldCallback
- noMarkupParserErrorFieldCallback_WithClosures :: Maybe MarkupParserErrorFieldCallback_WithClosures
- wrap_MarkupParserErrorFieldCallback :: Maybe (Ptr (FunPtr C_MarkupParserErrorFieldCallback)) -> MarkupParserErrorFieldCallback_WithClosures -> C_MarkupParserErrorFieldCallback
- type C_MarkupParserPassthroughFieldCallback = Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> Ptr (Ptr GError) -> IO ()
- type MarkupParserPassthroughFieldCallback = MarkupParseContext -> Text -> Word64 -> IO ()
- type MarkupParserPassthroughFieldCallback_WithClosures = MarkupParseContext -> Text -> Word64 -> Ptr () -> IO ()
- drop_closures_MarkupParserPassthroughFieldCallback :: MarkupParserPassthroughFieldCallback -> MarkupParserPassthroughFieldCallback_WithClosures
- dynamic_MarkupParserPassthroughFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MarkupParserPassthroughFieldCallback -> MarkupParseContext -> Text -> Word64 -> Ptr () -> m ()
- mk_MarkupParserPassthroughFieldCallback :: C_MarkupParserPassthroughFieldCallback -> IO (FunPtr C_MarkupParserPassthroughFieldCallback)
- noMarkupParserPassthroughFieldCallback :: Maybe MarkupParserPassthroughFieldCallback
- noMarkupParserPassthroughFieldCallback_WithClosures :: Maybe MarkupParserPassthroughFieldCallback_WithClosures
- type C_MarkupParserStartElementFieldCallback = Ptr MarkupParseContext -> CString -> CString -> CString -> Ptr () -> Ptr (Ptr GError) -> IO ()
- type MarkupParserStartElementFieldCallback = MarkupParseContext -> Text -> Text -> Text -> IO ()
- type MarkupParserStartElementFieldCallback_WithClosures = MarkupParseContext -> Text -> Text -> Text -> Ptr () -> IO ()
- drop_closures_MarkupParserStartElementFieldCallback :: MarkupParserStartElementFieldCallback -> MarkupParserStartElementFieldCallback_WithClosures
- dynamic_MarkupParserStartElementFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MarkupParserStartElementFieldCallback -> MarkupParseContext -> Text -> Text -> Text -> Ptr () -> m ()
- mk_MarkupParserStartElementFieldCallback :: C_MarkupParserStartElementFieldCallback -> IO (FunPtr C_MarkupParserStartElementFieldCallback)
- noMarkupParserStartElementFieldCallback :: Maybe MarkupParserStartElementFieldCallback
- noMarkupParserStartElementFieldCallback_WithClosures :: Maybe MarkupParserStartElementFieldCallback_WithClosures
- type C_MarkupParserTextFieldCallback = Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> Ptr (Ptr GError) -> IO ()
- type MarkupParserTextFieldCallback = MarkupParseContext -> Text -> Word64 -> IO ()
- type MarkupParserTextFieldCallback_WithClosures = MarkupParseContext -> Text -> Word64 -> Ptr () -> IO ()
- drop_closures_MarkupParserTextFieldCallback :: MarkupParserTextFieldCallback -> MarkupParserTextFieldCallback_WithClosures
- dynamic_MarkupParserTextFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MarkupParserTextFieldCallback -> MarkupParseContext -> Text -> Word64 -> Ptr () -> m ()
- mk_MarkupParserTextFieldCallback :: C_MarkupParserTextFieldCallback -> IO (FunPtr C_MarkupParserTextFieldCallback)
- noMarkupParserTextFieldCallback :: Maybe MarkupParserTextFieldCallback
- noMarkupParserTextFieldCallback_WithClosures :: Maybe MarkupParserTextFieldCallback_WithClosures
- type C_MemVTableCallocFieldCallback = Word64 -> Word64 -> IO (Ptr ())
- type MemVTableCallocFieldCallback = Word64 -> Word64 -> IO (Ptr ())
- dynamic_MemVTableCallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableCallocFieldCallback -> Word64 -> Word64 -> m (Ptr ())
- genClosure_MemVTableCallocFieldCallback :: MonadIO m => MemVTableCallocFieldCallback -> m (GClosure C_MemVTableCallocFieldCallback)
- mk_MemVTableCallocFieldCallback :: C_MemVTableCallocFieldCallback -> IO (FunPtr C_MemVTableCallocFieldCallback)
- noMemVTableCallocFieldCallback :: Maybe MemVTableCallocFieldCallback
- wrap_MemVTableCallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableCallocFieldCallback)) -> MemVTableCallocFieldCallback -> C_MemVTableCallocFieldCallback
- type C_MemVTableFreeFieldCallback = Ptr () -> IO ()
- type MemVTableFreeFieldCallback = IO ()
- type MemVTableFreeFieldCallback_WithClosures = Ptr () -> IO ()
- drop_closures_MemVTableFreeFieldCallback :: MemVTableFreeFieldCallback -> MemVTableFreeFieldCallback_WithClosures
- dynamic_MemVTableFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableFreeFieldCallback -> Ptr () -> m ()
- genClosure_MemVTableFreeFieldCallback :: MonadIO m => MemVTableFreeFieldCallback -> m (GClosure C_MemVTableFreeFieldCallback)
- mk_MemVTableFreeFieldCallback :: C_MemVTableFreeFieldCallback -> IO (FunPtr C_MemVTableFreeFieldCallback)
- noMemVTableFreeFieldCallback :: Maybe MemVTableFreeFieldCallback
- noMemVTableFreeFieldCallback_WithClosures :: Maybe MemVTableFreeFieldCallback_WithClosures
- wrap_MemVTableFreeFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableFreeFieldCallback)) -> MemVTableFreeFieldCallback_WithClosures -> C_MemVTableFreeFieldCallback
- type C_MemVTableMallocFieldCallback = Word64 -> IO (Ptr ())
- type MemVTableMallocFieldCallback = Word64 -> IO (Ptr ())
- dynamic_MemVTableMallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableMallocFieldCallback -> Word64 -> m (Ptr ())
- genClosure_MemVTableMallocFieldCallback :: MonadIO m => MemVTableMallocFieldCallback -> m (GClosure C_MemVTableMallocFieldCallback)
- mk_MemVTableMallocFieldCallback :: C_MemVTableMallocFieldCallback -> IO (FunPtr C_MemVTableMallocFieldCallback)
- noMemVTableMallocFieldCallback :: Maybe MemVTableMallocFieldCallback
- wrap_MemVTableMallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableMallocFieldCallback)) -> MemVTableMallocFieldCallback -> C_MemVTableMallocFieldCallback
- type C_MemVTableReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ())
- type MemVTableReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ())
- dynamic_MemVTableReallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableReallocFieldCallback -> Ptr () -> Word64 -> m (Ptr ())
- genClosure_MemVTableReallocFieldCallback :: MonadIO m => MemVTableReallocFieldCallback -> m (GClosure C_MemVTableReallocFieldCallback)
- mk_MemVTableReallocFieldCallback :: C_MemVTableReallocFieldCallback -> IO (FunPtr C_MemVTableReallocFieldCallback)
- noMemVTableReallocFieldCallback :: Maybe MemVTableReallocFieldCallback
- wrap_MemVTableReallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableReallocFieldCallback)) -> MemVTableReallocFieldCallback -> C_MemVTableReallocFieldCallback
- type C_MemVTableTryMallocFieldCallback = Word64 -> IO (Ptr ())
- type MemVTableTryMallocFieldCallback = Word64 -> IO (Ptr ())
- dynamic_MemVTableTryMallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableTryMallocFieldCallback -> Word64 -> m (Ptr ())
- genClosure_MemVTableTryMallocFieldCallback :: MonadIO m => MemVTableTryMallocFieldCallback -> m (GClosure C_MemVTableTryMallocFieldCallback)
- mk_MemVTableTryMallocFieldCallback :: C_MemVTableTryMallocFieldCallback -> IO (FunPtr C_MemVTableTryMallocFieldCallback)
- noMemVTableTryMallocFieldCallback :: Maybe MemVTableTryMallocFieldCallback
- wrap_MemVTableTryMallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableTryMallocFieldCallback)) -> MemVTableTryMallocFieldCallback -> C_MemVTableTryMallocFieldCallback
- type C_MemVTableTryReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ())
- type MemVTableTryReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ())
- dynamic_MemVTableTryReallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableTryReallocFieldCallback -> Ptr () -> Word64 -> m (Ptr ())
- genClosure_MemVTableTryReallocFieldCallback :: MonadIO m => MemVTableTryReallocFieldCallback -> m (GClosure C_MemVTableTryReallocFieldCallback)
- mk_MemVTableTryReallocFieldCallback :: C_MemVTableTryReallocFieldCallback -> IO (FunPtr C_MemVTableTryReallocFieldCallback)
- noMemVTableTryReallocFieldCallback :: Maybe MemVTableTryReallocFieldCallback
- wrap_MemVTableTryReallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableTryReallocFieldCallback)) -> MemVTableTryReallocFieldCallback -> C_MemVTableTryReallocFieldCallback
- type C_NodeForeachFunc = Ptr Node -> Ptr () -> IO ()
- type NodeForeachFunc = Node -> IO ()
- type NodeForeachFunc_WithClosures = Node -> Ptr () -> IO ()
- drop_closures_NodeForeachFunc :: NodeForeachFunc -> NodeForeachFunc_WithClosures
- dynamic_NodeForeachFunc :: (HasCallStack, MonadIO m) => FunPtr C_NodeForeachFunc -> Node -> Ptr () -> m ()
- genClosure_NodeForeachFunc :: MonadIO m => NodeForeachFunc -> m (GClosure C_NodeForeachFunc)
- mk_NodeForeachFunc :: C_NodeForeachFunc -> IO (FunPtr C_NodeForeachFunc)
- noNodeForeachFunc :: Maybe NodeForeachFunc
- noNodeForeachFunc_WithClosures :: Maybe NodeForeachFunc_WithClosures
- wrap_NodeForeachFunc :: Maybe (Ptr (FunPtr C_NodeForeachFunc)) -> NodeForeachFunc_WithClosures -> C_NodeForeachFunc
- type C_NodeTraverseFunc = Ptr Node -> Ptr () -> IO CInt
- type NodeTraverseFunc = Node -> IO Bool
- type NodeTraverseFunc_WithClosures = Node -> Ptr () -> IO Bool
- drop_closures_NodeTraverseFunc :: NodeTraverseFunc -> NodeTraverseFunc_WithClosures
- dynamic_NodeTraverseFunc :: (HasCallStack, MonadIO m) => FunPtr C_NodeTraverseFunc -> Node -> Ptr () -> m Bool
- genClosure_NodeTraverseFunc :: MonadIO m => NodeTraverseFunc -> m (GClosure C_NodeTraverseFunc)
- mk_NodeTraverseFunc :: C_NodeTraverseFunc -> IO (FunPtr C_NodeTraverseFunc)
- noNodeTraverseFunc :: Maybe NodeTraverseFunc
- noNodeTraverseFunc_WithClosures :: Maybe NodeTraverseFunc_WithClosures
- wrap_NodeTraverseFunc :: Maybe (Ptr (FunPtr C_NodeTraverseFunc)) -> NodeTraverseFunc_WithClosures -> C_NodeTraverseFunc
- type C_OptionArgFunc = CString -> CString -> Ptr () -> Ptr (Ptr GError) -> IO CInt
- type OptionArgFunc = Text -> Text -> IO ()
- type OptionArgFunc_WithClosures = Text -> Text -> Ptr () -> IO ()
- drop_closures_OptionArgFunc :: OptionArgFunc -> OptionArgFunc_WithClosures
- dynamic_OptionArgFunc :: (HasCallStack, MonadIO m) => FunPtr C_OptionArgFunc -> Text -> Text -> Ptr () -> m ()
- mk_OptionArgFunc :: C_OptionArgFunc -> IO (FunPtr C_OptionArgFunc)
- noOptionArgFunc :: Maybe OptionArgFunc
- noOptionArgFunc_WithClosures :: Maybe OptionArgFunc_WithClosures
- type C_OptionErrorFunc = Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> Ptr (Ptr GError) -> IO ()
- type OptionErrorFunc = OptionContext -> OptionGroup -> IO ()
- type OptionErrorFunc_WithClosures = OptionContext -> OptionGroup -> Ptr () -> IO ()
- drop_closures_OptionErrorFunc :: OptionErrorFunc -> OptionErrorFunc_WithClosures
- dynamic_OptionErrorFunc :: (HasCallStack, MonadIO m) => FunPtr C_OptionErrorFunc -> OptionContext -> OptionGroup -> Ptr () -> m ()
- mk_OptionErrorFunc :: C_OptionErrorFunc -> IO (FunPtr C_OptionErrorFunc)
- noOptionErrorFunc :: Maybe OptionErrorFunc
- noOptionErrorFunc_WithClosures :: Maybe OptionErrorFunc_WithClosures
- type C_OptionParseFunc = Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> Ptr (Ptr GError) -> IO CInt
- type OptionParseFunc = OptionContext -> OptionGroup -> IO ()
- type OptionParseFunc_WithClosures = OptionContext -> OptionGroup -> Ptr () -> IO ()
- drop_closures_OptionParseFunc :: OptionParseFunc -> OptionParseFunc_WithClosures
- dynamic_OptionParseFunc :: (HasCallStack, MonadIO m) => FunPtr C_OptionParseFunc -> OptionContext -> OptionGroup -> Ptr () -> m ()
- mk_OptionParseFunc :: C_OptionParseFunc -> IO (FunPtr C_OptionParseFunc)
- noOptionParseFunc :: Maybe OptionParseFunc
- noOptionParseFunc_WithClosures :: Maybe OptionParseFunc_WithClosures
- type C_PollFunc = Ptr PollFD -> Word32 -> Int32 -> IO Int32
- type PollFunc = PollFD -> Word32 -> Int32 -> IO Int32
- dynamic_PollFunc :: (HasCallStack, MonadIO m) => FunPtr C_PollFunc -> PollFD -> Word32 -> Int32 -> m Int32
- genClosure_PollFunc :: MonadIO m => PollFunc -> m (GClosure C_PollFunc)
- mk_PollFunc :: C_PollFunc -> IO (FunPtr C_PollFunc)
- noPollFunc :: Maybe PollFunc
- wrap_PollFunc :: Maybe (Ptr (FunPtr C_PollFunc)) -> PollFunc -> C_PollFunc
- type C_PrintFunc = CString -> IO ()
- type PrintFunc = Text -> IO ()
- dynamic_PrintFunc :: (HasCallStack, MonadIO m) => FunPtr C_PrintFunc -> Text -> m ()
- genClosure_PrintFunc :: MonadIO m => PrintFunc -> m (GClosure C_PrintFunc)
- mk_PrintFunc :: C_PrintFunc -> IO (FunPtr C_PrintFunc)
- noPrintFunc :: Maybe PrintFunc
- wrap_PrintFunc :: Maybe (Ptr (FunPtr C_PrintFunc)) -> PrintFunc -> C_PrintFunc
- type C_RegexEvalCallback = Ptr MatchInfo -> Ptr String -> Ptr () -> IO CInt
- type RegexEvalCallback = MatchInfo -> String -> IO Bool
- type RegexEvalCallback_WithClosures = MatchInfo -> String -> Ptr () -> IO Bool
- drop_closures_RegexEvalCallback :: RegexEvalCallback -> RegexEvalCallback_WithClosures
- dynamic_RegexEvalCallback :: (HasCallStack, MonadIO m) => FunPtr C_RegexEvalCallback -> MatchInfo -> String -> Ptr () -> m Bool
- genClosure_RegexEvalCallback :: MonadIO m => RegexEvalCallback -> m (GClosure C_RegexEvalCallback)
- mk_RegexEvalCallback :: C_RegexEvalCallback -> IO (FunPtr C_RegexEvalCallback)
- noRegexEvalCallback :: Maybe RegexEvalCallback
- noRegexEvalCallback_WithClosures :: Maybe RegexEvalCallback_WithClosures
- wrap_RegexEvalCallback :: Maybe (Ptr (FunPtr C_RegexEvalCallback)) -> RegexEvalCallback_WithClosures -> C_RegexEvalCallback
- type C_ScannerMsgFunc = Ptr Scanner -> CString -> CInt -> IO ()
- type ScannerMsgFunc = Scanner -> Text -> Bool -> IO ()
- dynamic_ScannerMsgFunc :: (HasCallStack, MonadIO m) => FunPtr C_ScannerMsgFunc -> Scanner -> Text -> Bool -> m ()
- genClosure_ScannerMsgFunc :: MonadIO m => ScannerMsgFunc -> m (GClosure C_ScannerMsgFunc)
- mk_ScannerMsgFunc :: C_ScannerMsgFunc -> IO (FunPtr C_ScannerMsgFunc)
- noScannerMsgFunc :: Maybe ScannerMsgFunc
- wrap_ScannerMsgFunc :: Maybe (Ptr (FunPtr C_ScannerMsgFunc)) -> ScannerMsgFunc -> C_ScannerMsgFunc
- type C_SequenceIterCompareFunc = Ptr SequenceIter -> Ptr SequenceIter -> Ptr () -> IO Int32
- type SequenceIterCompareFunc = SequenceIter -> SequenceIter -> IO Int32
- type SequenceIterCompareFunc_WithClosures = SequenceIter -> SequenceIter -> Ptr () -> IO Int32
- drop_closures_SequenceIterCompareFunc :: SequenceIterCompareFunc -> SequenceIterCompareFunc_WithClosures
- dynamic_SequenceIterCompareFunc :: (HasCallStack, MonadIO m) => FunPtr C_SequenceIterCompareFunc -> SequenceIter -> SequenceIter -> Ptr () -> m Int32
- genClosure_SequenceIterCompareFunc :: MonadIO m => SequenceIterCompareFunc -> m (GClosure C_SequenceIterCompareFunc)
- mk_SequenceIterCompareFunc :: C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc)
- noSequenceIterCompareFunc :: Maybe SequenceIterCompareFunc
- noSequenceIterCompareFunc_WithClosures :: Maybe SequenceIterCompareFunc_WithClosures
- wrap_SequenceIterCompareFunc :: Maybe (Ptr (FunPtr C_SequenceIterCompareFunc)) -> SequenceIterCompareFunc_WithClosures -> C_SequenceIterCompareFunc
- type C_SourceCallbackFuncsRefFieldCallback = Ptr () -> IO ()
- type SourceCallbackFuncsRefFieldCallback = IO ()
- type SourceCallbackFuncsRefFieldCallback_WithClosures = Ptr () -> IO ()
- drop_closures_SourceCallbackFuncsRefFieldCallback :: SourceCallbackFuncsRefFieldCallback -> SourceCallbackFuncsRefFieldCallback_WithClosures
- dynamic_SourceCallbackFuncsRefFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceCallbackFuncsRefFieldCallback -> Ptr () -> m ()
- genClosure_SourceCallbackFuncsRefFieldCallback :: MonadIO m => SourceCallbackFuncsRefFieldCallback -> m (GClosure C_SourceCallbackFuncsRefFieldCallback)
- mk_SourceCallbackFuncsRefFieldCallback :: C_SourceCallbackFuncsRefFieldCallback -> IO (FunPtr C_SourceCallbackFuncsRefFieldCallback)
- noSourceCallbackFuncsRefFieldCallback :: Maybe SourceCallbackFuncsRefFieldCallback
- noSourceCallbackFuncsRefFieldCallback_WithClosures :: Maybe SourceCallbackFuncsRefFieldCallback_WithClosures
- wrap_SourceCallbackFuncsRefFieldCallback :: Maybe (Ptr (FunPtr C_SourceCallbackFuncsRefFieldCallback)) -> SourceCallbackFuncsRefFieldCallback_WithClosures -> C_SourceCallbackFuncsRefFieldCallback
- type C_SourceCallbackFuncsUnrefFieldCallback = Ptr () -> IO ()
- type SourceCallbackFuncsUnrefFieldCallback = IO ()
- type SourceCallbackFuncsUnrefFieldCallback_WithClosures = Ptr () -> IO ()
- drop_closures_SourceCallbackFuncsUnrefFieldCallback :: SourceCallbackFuncsUnrefFieldCallback -> SourceCallbackFuncsUnrefFieldCallback_WithClosures
- dynamic_SourceCallbackFuncsUnrefFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceCallbackFuncsUnrefFieldCallback -> Ptr () -> m ()
- genClosure_SourceCallbackFuncsUnrefFieldCallback :: MonadIO m => SourceCallbackFuncsUnrefFieldCallback -> m (GClosure C_SourceCallbackFuncsUnrefFieldCallback)
- mk_SourceCallbackFuncsUnrefFieldCallback :: C_SourceCallbackFuncsUnrefFieldCallback -> IO (FunPtr C_SourceCallbackFuncsUnrefFieldCallback)
- noSourceCallbackFuncsUnrefFieldCallback :: Maybe SourceCallbackFuncsUnrefFieldCallback
- noSourceCallbackFuncsUnrefFieldCallback_WithClosures :: Maybe SourceCallbackFuncsUnrefFieldCallback_WithClosures
- wrap_SourceCallbackFuncsUnrefFieldCallback :: Maybe (Ptr (FunPtr C_SourceCallbackFuncsUnrefFieldCallback)) -> SourceCallbackFuncsUnrefFieldCallback_WithClosures -> C_SourceCallbackFuncsUnrefFieldCallback
- type C_SourceDisposeFunc = Ptr Source -> IO ()
- type SourceDisposeFunc = Source -> IO ()
- dynamic_SourceDisposeFunc :: (HasCallStack, MonadIO m) => FunPtr C_SourceDisposeFunc -> Source -> m ()
- genClosure_SourceDisposeFunc :: MonadIO m => SourceDisposeFunc -> m (GClosure C_SourceDisposeFunc)
- mk_SourceDisposeFunc :: C_SourceDisposeFunc -> IO (FunPtr C_SourceDisposeFunc)
- noSourceDisposeFunc :: Maybe SourceDisposeFunc
- wrap_SourceDisposeFunc :: Maybe (Ptr (FunPtr C_SourceDisposeFunc)) -> SourceDisposeFunc -> C_SourceDisposeFunc
- type C_SourceDummyMarshal = IO ()
- type SourceDummyMarshal = IO ()
- dynamic_SourceDummyMarshal :: (HasCallStack, MonadIO m) => FunPtr C_SourceDummyMarshal -> m ()
- genClosure_SourceDummyMarshal :: MonadIO m => SourceDummyMarshal -> m (GClosure C_SourceDummyMarshal)
- mk_SourceDummyMarshal :: C_SourceDummyMarshal -> IO (FunPtr C_SourceDummyMarshal)
- noSourceDummyMarshal :: Maybe SourceDummyMarshal
- wrap_SourceDummyMarshal :: Maybe (Ptr (FunPtr C_SourceDummyMarshal)) -> SourceDummyMarshal -> C_SourceDummyMarshal
- type C_SourceFunc = Ptr () -> IO CInt
- type SourceFunc = IO Bool
- type SourceFunc_WithClosures = Ptr () -> IO Bool
- drop_closures_SourceFunc :: SourceFunc -> SourceFunc_WithClosures
- dynamic_SourceFunc :: (HasCallStack, MonadIO m) => FunPtr C_SourceFunc -> Ptr () -> m Bool
- genClosure_SourceFunc :: MonadIO m => SourceFunc -> m (GClosure C_SourceFunc)
- mk_SourceFunc :: C_SourceFunc -> IO (FunPtr C_SourceFunc)
- noSourceFunc :: Maybe SourceFunc
- noSourceFunc_WithClosures :: Maybe SourceFunc_WithClosures
- wrap_SourceFunc :: Maybe (Ptr (FunPtr C_SourceFunc)) -> SourceFunc_WithClosures -> C_SourceFunc
- type C_SourceFuncsCheckFieldCallback = Ptr Source -> IO CInt
- type SourceFuncsCheckFieldCallback = Source -> IO Bool
- dynamic_SourceFuncsCheckFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsCheckFieldCallback -> Source -> m Bool
- genClosure_SourceFuncsCheckFieldCallback :: MonadIO m => SourceFuncsCheckFieldCallback -> m (GClosure C_SourceFuncsCheckFieldCallback)
- mk_SourceFuncsCheckFieldCallback :: C_SourceFuncsCheckFieldCallback -> IO (FunPtr C_SourceFuncsCheckFieldCallback)
- noSourceFuncsCheckFieldCallback :: Maybe SourceFuncsCheckFieldCallback
- wrap_SourceFuncsCheckFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsCheckFieldCallback)) -> SourceFuncsCheckFieldCallback -> C_SourceFuncsCheckFieldCallback
- type C_SourceFuncsFinalizeFieldCallback = Ptr Source -> IO ()
- type SourceFuncsFinalizeFieldCallback = Source -> IO ()
- dynamic_SourceFuncsFinalizeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsFinalizeFieldCallback -> Source -> m ()
- genClosure_SourceFuncsFinalizeFieldCallback :: MonadIO m => SourceFuncsFinalizeFieldCallback -> m (GClosure C_SourceFuncsFinalizeFieldCallback)
- mk_SourceFuncsFinalizeFieldCallback :: C_SourceFuncsFinalizeFieldCallback -> IO (FunPtr C_SourceFuncsFinalizeFieldCallback)
- noSourceFuncsFinalizeFieldCallback :: Maybe SourceFuncsFinalizeFieldCallback
- wrap_SourceFuncsFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsFinalizeFieldCallback)) -> SourceFuncsFinalizeFieldCallback -> C_SourceFuncsFinalizeFieldCallback
- type C_SourceFuncsPrepareFieldCallback = Ptr Source -> Int32 -> IO CInt
- type SourceFuncsPrepareFieldCallback = Source -> Int32 -> IO Bool
- dynamic_SourceFuncsPrepareFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsPrepareFieldCallback -> Source -> Int32 -> m Bool
- genClosure_SourceFuncsPrepareFieldCallback :: MonadIO m => SourceFuncsPrepareFieldCallback -> m (GClosure C_SourceFuncsPrepareFieldCallback)
- mk_SourceFuncsPrepareFieldCallback :: C_SourceFuncsPrepareFieldCallback -> IO (FunPtr C_SourceFuncsPrepareFieldCallback)
- noSourceFuncsPrepareFieldCallback :: Maybe SourceFuncsPrepareFieldCallback
- wrap_SourceFuncsPrepareFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsPrepareFieldCallback)) -> SourceFuncsPrepareFieldCallback -> C_SourceFuncsPrepareFieldCallback
- type C_SourceOnceFunc = Ptr () -> IO ()
- type SourceOnceFunc = IO ()
- type SourceOnceFunc_WithClosures = Ptr () -> IO ()
- drop_closures_SourceOnceFunc :: SourceOnceFunc -> SourceOnceFunc_WithClosures
- dynamic_SourceOnceFunc :: (HasCallStack, MonadIO m) => FunPtr C_SourceOnceFunc -> Ptr () -> m ()
- genClosure_SourceOnceFunc :: MonadIO m => SourceOnceFunc -> m (GClosure C_SourceOnceFunc)
- mk_SourceOnceFunc :: C_SourceOnceFunc -> IO (FunPtr C_SourceOnceFunc)
- noSourceOnceFunc :: Maybe SourceOnceFunc
- noSourceOnceFunc_WithClosures :: Maybe SourceOnceFunc_WithClosures
- wrap_SourceOnceFunc :: Maybe (Ptr (FunPtr C_SourceOnceFunc)) -> SourceOnceFunc_WithClosures -> C_SourceOnceFunc
- type C_SpawnChildSetupFunc = Ptr () -> IO ()
- type SpawnChildSetupFunc = IO ()
- type SpawnChildSetupFunc_WithClosures = Ptr () -> IO ()
- drop_closures_SpawnChildSetupFunc :: SpawnChildSetupFunc -> SpawnChildSetupFunc_WithClosures
- dynamic_SpawnChildSetupFunc :: (HasCallStack, MonadIO m) => FunPtr C_SpawnChildSetupFunc -> Ptr () -> m ()
- genClosure_SpawnChildSetupFunc :: MonadIO m => SpawnChildSetupFunc -> m (GClosure C_SpawnChildSetupFunc)
- mk_SpawnChildSetupFunc :: C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)
- noSpawnChildSetupFunc :: Maybe SpawnChildSetupFunc
- noSpawnChildSetupFunc_WithClosures :: Maybe SpawnChildSetupFunc_WithClosures
- wrap_SpawnChildSetupFunc :: Maybe (Ptr (FunPtr C_SpawnChildSetupFunc)) -> SpawnChildSetupFunc_WithClosures -> C_SpawnChildSetupFunc
- type C_TestDataFunc = Ptr () -> IO ()
- type TestDataFunc = IO ()
- type TestDataFunc_WithClosures = Ptr () -> IO ()
- drop_closures_TestDataFunc :: TestDataFunc -> TestDataFunc_WithClosures
- dynamic_TestDataFunc :: (HasCallStack, MonadIO m) => FunPtr C_TestDataFunc -> Ptr () -> m ()
- genClosure_TestDataFunc :: MonadIO m => TestDataFunc -> m (GClosure C_TestDataFunc)
- mk_TestDataFunc :: C_TestDataFunc -> IO (FunPtr C_TestDataFunc)
- noTestDataFunc :: Maybe TestDataFunc
- noTestDataFunc_WithClosures :: Maybe TestDataFunc_WithClosures
- wrap_TestDataFunc :: Maybe (Ptr (FunPtr C_TestDataFunc)) -> TestDataFunc_WithClosures -> C_TestDataFunc
- type C_TestFixtureFunc = Ptr () -> Ptr () -> IO ()
- type TestFixtureFunc = Ptr () -> IO ()
- type TestFixtureFunc_WithClosures = Ptr () -> Ptr () -> IO ()
- drop_closures_TestFixtureFunc :: TestFixtureFunc -> TestFixtureFunc_WithClosures
- dynamic_TestFixtureFunc :: (HasCallStack, MonadIO m) => FunPtr C_TestFixtureFunc -> Ptr () -> Ptr () -> m ()
- genClosure_TestFixtureFunc :: MonadIO m => TestFixtureFunc -> m (GClosure C_TestFixtureFunc)
- mk_TestFixtureFunc :: C_TestFixtureFunc -> IO (FunPtr C_TestFixtureFunc)
- noTestFixtureFunc :: Maybe TestFixtureFunc
- noTestFixtureFunc_WithClosures :: Maybe TestFixtureFunc_WithClosures
- wrap_TestFixtureFunc :: Maybe (Ptr (FunPtr C_TestFixtureFunc)) -> TestFixtureFunc_WithClosures -> C_TestFixtureFunc
- type C_TestFunc = IO ()
- type TestFunc = IO ()
- dynamic_TestFunc :: (HasCallStack, MonadIO m) => FunPtr C_TestFunc -> m ()
- genClosure_TestFunc :: MonadIO m => TestFunc -> m (GClosure C_TestFunc)
- mk_TestFunc :: C_TestFunc -> IO (FunPtr C_TestFunc)
- noTestFunc :: Maybe TestFunc
- wrap_TestFunc :: Maybe (Ptr (FunPtr C_TestFunc)) -> TestFunc -> C_TestFunc
- type C_TestLogFatalFunc = CString -> CInt -> CString -> Ptr () -> IO CInt
- type TestLogFatalFunc = Text -> [LogLevelFlags] -> Text -> IO Bool
- type TestLogFatalFunc_WithClosures = Text -> [LogLevelFlags] -> Text -> Ptr () -> IO Bool
- drop_closures_TestLogFatalFunc :: TestLogFatalFunc -> TestLogFatalFunc_WithClosures
- dynamic_TestLogFatalFunc :: (HasCallStack, MonadIO m) => FunPtr C_TestLogFatalFunc -> Text -> [LogLevelFlags] -> Text -> Ptr () -> m Bool
- genClosure_TestLogFatalFunc :: MonadIO m => TestLogFatalFunc -> m (GClosure C_TestLogFatalFunc)
- mk_TestLogFatalFunc :: C_TestLogFatalFunc -> IO (FunPtr C_TestLogFatalFunc)
- noTestLogFatalFunc :: Maybe TestLogFatalFunc
- noTestLogFatalFunc_WithClosures :: Maybe TestLogFatalFunc_WithClosures
- wrap_TestLogFatalFunc :: Maybe (Ptr (FunPtr C_TestLogFatalFunc)) -> TestLogFatalFunc_WithClosures -> C_TestLogFatalFunc
- type C_ThreadFunc = Ptr () -> IO (Ptr ())
- type ThreadFunc = IO (Ptr ())
- type ThreadFunc_WithClosures = Ptr () -> IO (Ptr ())
- drop_closures_ThreadFunc :: ThreadFunc -> ThreadFunc_WithClosures
- dynamic_ThreadFunc :: (HasCallStack, MonadIO m) => FunPtr C_ThreadFunc -> Ptr () -> m (Ptr ())
- genClosure_ThreadFunc :: MonadIO m => ThreadFunc -> m (GClosure C_ThreadFunc)
- mk_ThreadFunc :: C_ThreadFunc -> IO (FunPtr C_ThreadFunc)
- noThreadFunc :: Maybe ThreadFunc
- noThreadFunc_WithClosures :: Maybe ThreadFunc_WithClosures
- wrap_ThreadFunc :: Maybe (Ptr (FunPtr C_ThreadFunc)) -> ThreadFunc_WithClosures -> C_ThreadFunc
- type C_TranslateFunc = CString -> Ptr () -> IO CString
- type TranslateFunc = Text -> IO Text
- type TranslateFunc_WithClosures = Text -> Ptr () -> IO Text
- drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures
- dynamic_TranslateFunc :: (HasCallStack, MonadIO m) => FunPtr C_TranslateFunc -> Text -> Ptr () -> m Text
- genClosure_TranslateFunc :: MonadIO m => TranslateFunc -> m (GClosure C_TranslateFunc)
- mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc)
- noTranslateFunc :: Maybe TranslateFunc
- noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures
- wrap_TranslateFunc :: Maybe (Ptr (FunPtr C_TranslateFunc)) -> TranslateFunc_WithClosures -> C_TranslateFunc
- type C_TraverseFunc = Ptr () -> Ptr () -> Ptr () -> IO CInt
- type TraverseFunc = Ptr () -> Ptr () -> IO Bool
- type TraverseFunc_WithClosures = Ptr () -> Ptr () -> Ptr () -> IO Bool
- drop_closures_TraverseFunc :: TraverseFunc -> TraverseFunc_WithClosures
- dynamic_TraverseFunc :: (HasCallStack, MonadIO m) => FunPtr C_TraverseFunc -> Ptr () -> Ptr () -> Ptr () -> m Bool
- genClosure_TraverseFunc :: MonadIO m => TraverseFunc -> m (GClosure C_TraverseFunc)
- mk_TraverseFunc :: C_TraverseFunc -> IO (FunPtr C_TraverseFunc)
- noTraverseFunc :: Maybe TraverseFunc
- noTraverseFunc_WithClosures :: Maybe TraverseFunc_WithClosures
- wrap_TraverseFunc :: Maybe (Ptr (FunPtr C_TraverseFunc)) -> TraverseFunc_WithClosures -> C_TraverseFunc
- type C_TraverseNodeFunc = Ptr TreeNode -> Ptr () -> IO CInt
- type TraverseNodeFunc = TreeNode -> IO Bool
- type TraverseNodeFunc_WithClosures = TreeNode -> Ptr () -> IO Bool
- drop_closures_TraverseNodeFunc :: TraverseNodeFunc -> TraverseNodeFunc_WithClosures
- dynamic_TraverseNodeFunc :: (HasCallStack, MonadIO m) => FunPtr C_TraverseNodeFunc -> TreeNode -> Ptr () -> m Bool
- genClosure_TraverseNodeFunc :: MonadIO m => TraverseNodeFunc -> m (GClosure C_TraverseNodeFunc)
- mk_TraverseNodeFunc :: C_TraverseNodeFunc -> IO (FunPtr C_TraverseNodeFunc)
- noTraverseNodeFunc :: Maybe TraverseNodeFunc
- noTraverseNodeFunc_WithClosures :: Maybe TraverseNodeFunc_WithClosures
- wrap_TraverseNodeFunc :: Maybe (Ptr (FunPtr C_TraverseNodeFunc)) -> TraverseNodeFunc_WithClosures -> C_TraverseNodeFunc
- type C_UnixFDSourceFunc = Int32 -> CUInt -> Ptr () -> IO CInt
- type UnixFDSourceFunc = Int32 -> [IOCondition] -> IO Bool
- type UnixFDSourceFunc_WithClosures = Int32 -> [IOCondition] -> Ptr () -> IO Bool
- drop_closures_UnixFDSourceFunc :: UnixFDSourceFunc -> UnixFDSourceFunc_WithClosures
- dynamic_UnixFDSourceFunc :: (HasCallStack, MonadIO m) => FunPtr C_UnixFDSourceFunc -> Int32 -> [IOCondition] -> Ptr () -> m Bool
- genClosure_UnixFDSourceFunc :: MonadIO m => UnixFDSourceFunc -> m (GClosure C_UnixFDSourceFunc)
- mk_UnixFDSourceFunc :: C_UnixFDSourceFunc -> IO (FunPtr C_UnixFDSourceFunc)
- noUnixFDSourceFunc :: Maybe UnixFDSourceFunc
- noUnixFDSourceFunc_WithClosures :: Maybe UnixFDSourceFunc_WithClosures
- wrap_UnixFDSourceFunc :: Maybe (Ptr (FunPtr C_UnixFDSourceFunc)) -> UnixFDSourceFunc_WithClosures -> C_UnixFDSourceFunc
- type C_VoidFunc = IO ()
- type VoidFunc = IO ()
- dynamic_VoidFunc :: (HasCallStack, MonadIO m) => FunPtr C_VoidFunc -> m ()
- genClosure_VoidFunc :: MonadIO m => VoidFunc -> m (GClosure C_VoidFunc)
- mk_VoidFunc :: C_VoidFunc -> IO (FunPtr C_VoidFunc)
- noVoidFunc :: Maybe VoidFunc
- wrap_VoidFunc :: Maybe (Ptr (FunPtr C_VoidFunc)) -> VoidFunc -> C_VoidFunc

# Signals

## CacheDestroyFunc

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

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

type CacheDestroyFunc = IO () Source #

Deprecated: (Since version 2.32)Use a `HashTable` instead

Specifies the type of the `valueDestroyFunc` and `keyDestroyFunc` functions passed to `g_cache_new()`. The functions are passed a pointer to the `Cache` key or `Cache` value and should free any memory and other resources associated with it.

type CacheDestroyFunc_WithClosures Source #

Arguments

= Ptr () | `value`: the `Cache` value to destroy
-> IO () |

Specifies the type of the `valueDestroyFunc` and `keyDestroyFunc` functions passed to `g_cache_new()`. The functions are passed a pointer to the `Cache` key or `Cache` value and should free any memory and other resources associated with it.

drop_closures_CacheDestroyFunc :: CacheDestroyFunc -> CacheDestroyFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CacheDestroyFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_CacheDestroyFunc |
-> Ptr () | `value`: the `Cache` value to destroy
-> m () |

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

genClosure_CacheDestroyFunc :: MonadIO m => CacheDestroyFunc -> m (GClosure C_CacheDestroyFunc) Source #

Wrap the callback into a `GClosure`.

mk_CacheDestroyFunc :: C_CacheDestroyFunc -> IO (FunPtr C_CacheDestroyFunc) Source #

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

noCacheDestroyFunc :: Maybe CacheDestroyFunc Source #

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

noCacheDestroyFunc_WithClosures :: Maybe CacheDestroyFunc_WithClosures Source #

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

wrap_CacheDestroyFunc :: Maybe (Ptr (FunPtr C_CacheDestroyFunc)) -> CacheDestroyFunc_WithClosures -> C_CacheDestroyFunc Source #

Wrap a `CacheDestroyFunc` into a `C_CacheDestroyFunc`.

## CacheDupFunc

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

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

type CacheDupFunc Source #

Arguments

= IO (Ptr ()) | Returns: a copy of the `Cache` key

Deprecated: (Since version 2.32)Use a `HashTable` instead

Specifies the type of the `keyDupFunc` function passed to `g_cache_new()`. The function is passed a key (not a value as the prototype implies) and should return a duplicate of the key.

type CacheDupFunc_WithClosures Source #

Arguments

= Ptr () | `value`: the `Cache` key to destroy (not a `Cache` value as it seems)
-> IO (Ptr ()) | Returns: a copy of the `Cache` key

Specifies the type of the `keyDupFunc` function passed to `g_cache_new()`. The function is passed a key (not a value as the prototype implies) and should return a duplicate of the key.

drop_closures_CacheDupFunc :: CacheDupFunc -> CacheDupFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CacheDupFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_CacheDupFunc |
-> Ptr () | `value`: the `Cache` key to destroy (not a `Cache` value as it seems)
-> m (Ptr ()) | Returns: a copy of the `Cache` key

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

genClosure_CacheDupFunc :: MonadIO m => CacheDupFunc -> m (GClosure C_CacheDupFunc) Source #

Wrap the callback into a `GClosure`.

mk_CacheDupFunc :: C_CacheDupFunc -> IO (FunPtr C_CacheDupFunc) Source #

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

noCacheDupFunc :: Maybe CacheDupFunc Source #

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

noCacheDupFunc_WithClosures :: Maybe CacheDupFunc_WithClosures Source #

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

wrap_CacheDupFunc :: Maybe (Ptr (FunPtr C_CacheDupFunc)) -> CacheDupFunc_WithClosures -> C_CacheDupFunc Source #

Wrap a `CacheDupFunc` into a `C_CacheDupFunc`.

## CacheNewFunc

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

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

type CacheNewFunc Source #

Arguments

= IO (Ptr ()) | Returns: a new `Cache` value corresponding to the key.

Deprecated: (Since version 2.32)Use a `HashTable` instead

Specifies the type of the `valueNewFunc` function passed to `g_cache_new()`. It is passed a `Cache` key and should create the value corresponding to the key.

type CacheNewFunc_WithClosures Source #

Arguments

= Ptr () | `key`: a `Cache` key
-> IO (Ptr ()) | Returns: a new `Cache` value corresponding to the key.

Specifies the type of the `valueNewFunc` function passed to `g_cache_new()`. It is passed a `Cache` key and should create the value corresponding to the key.

drop_closures_CacheNewFunc :: CacheNewFunc -> CacheNewFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CacheNewFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_CacheNewFunc |
-> Ptr () | `key`: a `Cache` key
-> m (Ptr ()) | Returns: a new `Cache` value corresponding to the key.

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

genClosure_CacheNewFunc :: MonadIO m => CacheNewFunc -> m (GClosure C_CacheNewFunc) Source #

Wrap the callback into a `GClosure`.

mk_CacheNewFunc :: C_CacheNewFunc -> IO (FunPtr C_CacheNewFunc) Source #

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

noCacheNewFunc :: Maybe CacheNewFunc Source #

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

noCacheNewFunc_WithClosures :: Maybe CacheNewFunc_WithClosures Source #

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

wrap_CacheNewFunc :: Maybe (Ptr (FunPtr C_CacheNewFunc)) -> CacheNewFunc_WithClosures -> C_CacheNewFunc Source #

Wrap a `CacheNewFunc` into a `C_CacheNewFunc`.

## ChildWatchFunc

type C_ChildWatchFunc = Int32 -> Int32 -> Ptr () -> IO () Source #

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

type ChildWatchFunc Source #

Arguments

= Int32 | `pid`: the process id of the child process
-> Int32 | `waitStatus`: Status information about the child process, encoded in a platform-specific manner
-> IO () |

Prototype of a `GChildWatchSource` callback, called when a child process has exited.

To interpret `waitStatus`, see the documentation for `spawnCheckWaitStatus`. In particular, on Unix platforms, note that it is usually not equal to the integer passed to `exit()` or returned from `main()`.

type ChildWatchFunc_WithClosures Source #

Arguments

= Int32 | `pid`: the process id of the child process
-> Int32 | `waitStatus`: Status information about the child process, encoded in a platform-specific manner
-> Ptr () | `userData`: user data passed to `g_child_watch_add()`
-> IO () |

Prototype of a `GChildWatchSource` callback, called when a child process has exited.

To interpret `waitStatus`, see the documentation for `spawnCheckWaitStatus`. In particular, on Unix platforms, note that it is usually not equal to the integer passed to `exit()` or returned from `main()`.

drop_closures_ChildWatchFunc :: ChildWatchFunc -> ChildWatchFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ChildWatchFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ChildWatchFunc |
-> Int32 | `pid`: the process id of the child process
-> Int32 | `waitStatus`: Status information about the child process, encoded in a platform-specific manner
-> Ptr () | `userData`: user data passed to `g_child_watch_add()`
-> m () |

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

genClosure_ChildWatchFunc :: MonadIO m => ChildWatchFunc -> m (GClosure C_ChildWatchFunc) Source #

Wrap the callback into a `GClosure`.

mk_ChildWatchFunc :: C_ChildWatchFunc -> IO (FunPtr C_ChildWatchFunc) Source #

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

noChildWatchFunc :: Maybe ChildWatchFunc Source #

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

noChildWatchFunc_WithClosures :: Maybe ChildWatchFunc_WithClosures Source #

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

wrap_ChildWatchFunc :: Maybe (Ptr (FunPtr C_ChildWatchFunc)) -> ChildWatchFunc_WithClosures -> C_ChildWatchFunc Source #

Wrap a `ChildWatchFunc` into a `C_ChildWatchFunc`.

## ClearHandleFunc

type C_ClearHandleFunc = Word32 -> IO () Source #

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

type ClearHandleFunc Source #

Arguments

= Word32 | `handleId`: the handle ID to clear
-> IO () |

Specifies the type of function passed to `g_clear_handle_id()`. The implementation is expected to free the resource identified by `handleId`; for instance, if `handleId` is a `Source` ID, `sourceRemove` can be used.

Since: 2.56

dynamic_ClearHandleFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ClearHandleFunc |
-> Word32 | `handleId`: the handle ID to clear
-> m () |

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

genClosure_ClearHandleFunc :: MonadIO m => ClearHandleFunc -> m (GClosure C_ClearHandleFunc) Source #

Wrap the callback into a `GClosure`.

mk_ClearHandleFunc :: C_ClearHandleFunc -> IO (FunPtr C_ClearHandleFunc) Source #

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

noClearHandleFunc :: Maybe ClearHandleFunc Source #

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

wrap_ClearHandleFunc :: Maybe (Ptr (FunPtr C_ClearHandleFunc)) -> ClearHandleFunc -> C_ClearHandleFunc Source #

Wrap a `ClearHandleFunc` into a `C_ClearHandleFunc`.

## CompareDataFunc

type C_CompareDataFunc = Ptr () -> Ptr () -> Ptr () -> IO Int32 Source #

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

type CompareDataFunc Source #

Arguments

= Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> IO Int32 | Returns: negative value if `a` < `b`; zero if `a` = `b`; positive value if `a` > `b`

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

type CompareDataFunc_WithClosures Source #

Arguments

= Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> Ptr () | `userData`: user data
-> IO Int32 | Returns: negative value if `a` < `b`; zero if `a` = `b`; positive value if `a` > `b`

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

drop_closures_CompareDataFunc :: CompareDataFunc -> CompareDataFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CompareDataFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_CompareDataFunc |
-> Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> Ptr () | `userData`: user data
-> m Int32 | Returns: negative value if `a` < `b`; zero if `a` = `b`; positive value if `a` > `b`

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

genClosure_CompareDataFunc :: MonadIO m => CompareDataFunc -> m (GClosure C_CompareDataFunc) Source #

Wrap the callback into a `GClosure`.

mk_CompareDataFunc :: C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc) Source #

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

noCompareDataFunc :: Maybe CompareDataFunc Source #

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

noCompareDataFunc_WithClosures :: Maybe CompareDataFunc_WithClosures Source #

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

wrap_CompareDataFunc :: Maybe (Ptr (FunPtr C_CompareDataFunc)) -> CompareDataFunc_WithClosures -> C_CompareDataFunc Source #

Wrap a `CompareDataFunc` into a `C_CompareDataFunc`.

## CompareFunc

type C_CompareFunc = Ptr () -> Ptr () -> IO Int32 Source #

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

type CompareFunc Source #

Arguments

= Ptr () | `a`: a value
-> IO Int32 | Returns: negative value if `a` < `b`; zero if `a` = `b`; positive value if `a` > `b`

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

type CompareFunc_WithClosures Source #

Arguments

= Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> IO Int32 | Returns: negative value if `a` < `b`; zero if `a` = `b`; positive value if `a` > `b`

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

drop_closures_CompareFunc :: CompareFunc -> CompareFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CompareFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_CompareFunc |
-> Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> m Int32 | Returns: negative value if `a` < `b`; zero if `a` = `b`; positive value if `a` > `b`

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

genClosure_CompareFunc :: MonadIO m => CompareFunc -> m (GClosure C_CompareFunc) Source #

Wrap the callback into a `GClosure`.

mk_CompareFunc :: C_CompareFunc -> IO (FunPtr C_CompareFunc) Source #

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

noCompareFunc :: Maybe CompareFunc Source #

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

noCompareFunc_WithClosures :: Maybe CompareFunc_WithClosures Source #

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

wrap_CompareFunc :: Maybe (Ptr (FunPtr C_CompareFunc)) -> CompareFunc_WithClosures -> C_CompareFunc Source #

Wrap a `CompareFunc` into a `C_CompareFunc`.

## CompletionFunc

type C_CompletionFunc = Ptr () -> IO CString Source #

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

type CompletionFunc Source #

Arguments

= IO Text | Returns: the string corresponding to the item.

Deprecated: (Since version 2.26)Rarely used API

Specifies the type of the function passed to `g_completion_new()`. It should return the string corresponding to the given target item. This is used when you use data structures as `Completion` items.

type CompletionFunc_WithClosures Source #

Arguments

= Ptr () | `item`: the completion item.
-> IO Text | Returns: the string corresponding to the item.

Specifies the type of the function passed to `g_completion_new()`. It should return the string corresponding to the given target item. This is used when you use data structures as `Completion` items.

drop_closures_CompletionFunc :: CompletionFunc -> CompletionFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CompletionFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_CompletionFunc |
-> Ptr () | `item`: the completion item.
-> m Text | Returns: the string corresponding to the item.

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

genClosure_CompletionFunc :: MonadIO m => CompletionFunc -> m (GClosure C_CompletionFunc) Source #

Wrap the callback into a `GClosure`.

mk_CompletionFunc :: C_CompletionFunc -> IO (FunPtr C_CompletionFunc) Source #

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

noCompletionFunc :: Maybe CompletionFunc Source #

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

noCompletionFunc_WithClosures :: Maybe CompletionFunc_WithClosures Source #

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

wrap_CompletionFunc :: Maybe (Ptr (FunPtr C_CompletionFunc)) -> CompletionFunc_WithClosures -> C_CompletionFunc Source #

Wrap a `CompletionFunc` into a `C_CompletionFunc`.

## CompletionStrncmpFunc

type C_CompletionStrncmpFunc = CString -> CString -> Word64 -> IO Int32 Source #

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

type CompletionStrncmpFunc Source #

Arguments

= Text | `s1`: string to compare with `s2`.
-> Text | `s2`: string to compare with `s1`.
-> Word64 | `n`: maximal number of bytes to compare.
-> IO Int32 | Returns: an integer less than, equal to, or greater than zero if the first `n` bytes of `s1` is found, respectively, to be less than, to match, or to be greater than the first `n` bytes of `s2`.

Deprecated: (Since version 2.26)Rarely used API

Specifies the type of the function passed to `g_completion_set_compare()`. This is used when you use strings as `Completion` items.

dynamic_CompletionStrncmpFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_CompletionStrncmpFunc |
-> Text | `s1`: string to compare with `s2`.
-> Text | `s2`: string to compare with `s1`.
-> Word64 | `n`: maximal number of bytes to compare.
-> m Int32 | Returns: an integer less than, equal to, or greater than zero if the first `n` bytes of `s1` is found, respectively, to be less than, to match, or to be greater than the first `n` bytes of `s2`.

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

genClosure_CompletionStrncmpFunc :: MonadIO m => CompletionStrncmpFunc -> m (GClosure C_CompletionStrncmpFunc) Source #

Wrap the callback into a `GClosure`.

mk_CompletionStrncmpFunc :: C_CompletionStrncmpFunc -> IO (FunPtr C_CompletionStrncmpFunc) Source #

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

noCompletionStrncmpFunc :: Maybe CompletionStrncmpFunc Source #

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

wrap_CompletionStrncmpFunc :: Maybe (Ptr (FunPtr C_CompletionStrncmpFunc)) -> CompletionStrncmpFunc -> C_CompletionStrncmpFunc Source #

Wrap a `CompletionStrncmpFunc` into a `C_CompletionStrncmpFunc`.

## CopyFunc

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

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

type CopyFunc Source #

Arguments

= Ptr () | `src`: A pointer to the data which should be copied
-> IO (Ptr ()) | Returns: A pointer to the copy

A function of this signature is used to copy the node data when doing a deep-copy of a tree.

Since: 2.4

type CopyFunc_WithClosures Source #

Arguments

= Ptr () | `src`: A pointer to the data which should be copied
-> Ptr () | `data`: Additional data
-> IO (Ptr ()) | Returns: A pointer to the copy

A function of this signature is used to copy the node data when doing a deep-copy of a tree.

Since: 2.4

drop_closures_CopyFunc :: CopyFunc -> CopyFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CopyFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_CopyFunc |
-> Ptr () | `src`: A pointer to the data which should be copied
-> Ptr () | `data`: Additional data
-> m (Ptr ()) | Returns: A pointer to the copy

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

genClosure_CopyFunc :: MonadIO m => CopyFunc -> m (GClosure C_CopyFunc) Source #

Wrap the callback into a `GClosure`.

mk_CopyFunc :: C_CopyFunc -> IO (FunPtr C_CopyFunc) Source #

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

noCopyFunc :: Maybe CopyFunc Source #

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

noCopyFunc_WithClosures :: Maybe CopyFunc_WithClosures Source #

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

wrap_CopyFunc :: Maybe (Ptr (FunPtr C_CopyFunc)) -> CopyFunc_WithClosures -> C_CopyFunc Source #

Wrap a `CopyFunc` into a `C_CopyFunc`.

## DataForeachFunc

type C_DataForeachFunc = Word32 -> Ptr () -> Ptr () -> IO () Source #

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

type DataForeachFunc Source #

Arguments

= Word32 | `keyId`: the `GQuark` id to identifying the data element.
-> Ptr () | `data`: the data element.
-> IO () |

Specifies the type of function passed to `datasetForeach`. It is called with each `GQuark` id and associated data element, together with the `userData` parameter supplied to `datasetForeach`.

type DataForeachFunc_WithClosures Source #

Arguments

= Word32 | `keyId`: the `GQuark` id to identifying the data element.
-> Ptr () | `data`: the data element.
-> Ptr () | `userData`: user data passed to `datasetForeach`.
-> IO () |

Specifies the type of function passed to `datasetForeach`. It is called with each `GQuark` id and associated data element, together with the `userData` parameter supplied to `datasetForeach`.

drop_closures_DataForeachFunc :: DataForeachFunc -> DataForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DataForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_DataForeachFunc |
-> Word32 | `keyId`: the `GQuark` id to identifying the data element.
-> Ptr () | `data`: the data element.
-> Ptr () | `userData`: user data passed to `datasetForeach`.
-> m () |

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

genClosure_DataForeachFunc :: MonadIO m => DataForeachFunc -> m (GClosure C_DataForeachFunc) Source #

Wrap the callback into a `GClosure`.

mk_DataForeachFunc :: C_DataForeachFunc -> IO (FunPtr C_DataForeachFunc) Source #

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

noDataForeachFunc :: Maybe DataForeachFunc Source #

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

noDataForeachFunc_WithClosures :: Maybe DataForeachFunc_WithClosures Source #

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

wrap_DataForeachFunc :: Maybe (Ptr (FunPtr C_DataForeachFunc)) -> DataForeachFunc_WithClosures -> C_DataForeachFunc Source #

Wrap a `DataForeachFunc` into a `C_DataForeachFunc`.

## DestroyNotify

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

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

type DestroyNotify = IO () Source #

Specifies the type of function which is called when a data element is destroyed. It is passed the pointer to the data element and should free any memory and resources allocated for it.

type DestroyNotify_WithClosures Source #

Arguments

= Ptr () | `data`: the data element.
-> IO () |

Specifies the type of function which is called when a data element is destroyed. It is passed the pointer to the data element and should free any memory and resources allocated for it.

drop_closures_DestroyNotify :: DestroyNotify -> DestroyNotify_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DestroyNotify Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_DestroyNotify |
-> Ptr () | `data`: the data element.
-> m () |

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

genClosure_DestroyNotify :: MonadIO m => DestroyNotify -> m (GClosure C_DestroyNotify) Source #

Wrap the callback into a `GClosure`.

mk_DestroyNotify :: C_DestroyNotify -> IO (FunPtr C_DestroyNotify) Source #

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

noDestroyNotify :: Maybe DestroyNotify Source #

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

noDestroyNotify_WithClosures :: Maybe DestroyNotify_WithClosures Source #

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

wrap_DestroyNotify :: Maybe (Ptr (FunPtr C_DestroyNotify)) -> DestroyNotify_WithClosures -> C_DestroyNotify Source #

Wrap a `DestroyNotify` into a `C_DestroyNotify`.

## DuplicateFunc

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

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

type DuplicateFunc Source #

Arguments

= Ptr () | `data`: the data to duplicate
-> IO (Ptr ()) | Returns: a duplicate of data

The type of functions that are used to 'duplicate' an object. What this means depends on the context, it could just be incrementing the reference count, if `data` is a ref-counted object.

type DuplicateFunc_WithClosures Source #

Arguments

= Ptr () | `data`: the data to duplicate
-> Ptr () | `userData`: user data that was specified in `g_datalist_id_dup_data()`
-> IO (Ptr ()) | Returns: a duplicate of data

The type of functions that are used to 'duplicate' an object. What this means depends on the context, it could just be incrementing the reference count, if `data` is a ref-counted object.

drop_closures_DuplicateFunc :: DuplicateFunc -> DuplicateFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DuplicateFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_DuplicateFunc |
-> Ptr () | `data`: the data to duplicate
-> Ptr () | `userData`: user data that was specified in `g_datalist_id_dup_data()`
-> m (Ptr ()) | Returns: a duplicate of data

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

genClosure_DuplicateFunc :: MonadIO m => DuplicateFunc -> m (GClosure C_DuplicateFunc) Source #

Wrap the callback into a `GClosure`.

mk_DuplicateFunc :: C_DuplicateFunc -> IO (FunPtr C_DuplicateFunc) Source #

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

noDuplicateFunc :: Maybe DuplicateFunc Source #

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

noDuplicateFunc_WithClosures :: Maybe DuplicateFunc_WithClosures Source #

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

wrap_DuplicateFunc :: Maybe (Ptr (FunPtr C_DuplicateFunc)) -> DuplicateFunc_WithClosures -> C_DuplicateFunc Source #

Wrap a `DuplicateFunc` into a `C_DuplicateFunc`.

## EqualFunc

type C_EqualFunc = Ptr () -> Ptr () -> IO CInt Source #

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

type EqualFunc Source #

Arguments

= Ptr () | `a`: a value
-> IO Bool | Returns: `True` if `a` = `b`; `False` otherwise

Specifies the type of a function used to test two values for equality. The function should return `True` if both values are equal and `False` otherwise.

type EqualFunc_WithClosures Source #

Arguments

= Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> IO Bool | Returns: `True` if `a` = `b`; `False` otherwise

Specifies the type of a function used to test two values for equality. The function should return `True` if both values are equal and `False` otherwise.

drop_closures_EqualFunc :: EqualFunc -> EqualFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_EqualFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_EqualFunc |
-> Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> m Bool | Returns: `True` if `a` = `b`; `False` otherwise

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

genClosure_EqualFunc :: MonadIO m => EqualFunc -> m (GClosure C_EqualFunc) Source #

Wrap the callback into a `GClosure`.

mk_EqualFunc :: C_EqualFunc -> IO (FunPtr C_EqualFunc) Source #

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

noEqualFunc :: Maybe EqualFunc Source #

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

noEqualFunc_WithClosures :: Maybe EqualFunc_WithClosures Source #

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

wrap_EqualFunc :: Maybe (Ptr (FunPtr C_EqualFunc)) -> EqualFunc_WithClosures -> C_EqualFunc Source #

Wrap a `EqualFunc` into a `C_EqualFunc`.

## EqualFuncFull

type C_EqualFuncFull = Ptr () -> Ptr () -> Ptr () -> IO CInt Source #

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

type EqualFuncFull Source #

Arguments

= Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> IO Bool | Returns: `True` if `a` = `b`; `False` otherwise

Specifies the type of a function used to test two values for equality. The function should return `True` if both values are equal and `False` otherwise.

This is a version of `EqualFunc` which provides a `userData` closure from the caller.

Since: 2.74

type EqualFuncFull_WithClosures Source #

Arguments

= Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> Ptr () | `userData`: user data provided by the caller
-> IO Bool | Returns: `True` if `a` = `b`; `False` otherwise

Specifies the type of a function used to test two values for equality. The function should return `True` if both values are equal and `False` otherwise.

This is a version of `EqualFunc` which provides a `userData` closure from the caller.

Since: 2.74

drop_closures_EqualFuncFull :: EqualFuncFull -> EqualFuncFull_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_EqualFuncFull Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_EqualFuncFull |
-> Ptr () | `a`: a value
-> Ptr () | `b`: a value to compare with
-> Ptr () | `userData`: user data provided by the caller
-> m Bool | Returns: `True` if `a` = `b`; `False` otherwise

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

genClosure_EqualFuncFull :: MonadIO m => EqualFuncFull -> m (GClosure C_EqualFuncFull) Source #

Wrap the callback into a `GClosure`.

mk_EqualFuncFull :: C_EqualFuncFull -> IO (FunPtr C_EqualFuncFull) Source #

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

noEqualFuncFull :: Maybe EqualFuncFull Source #

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

noEqualFuncFull_WithClosures :: Maybe EqualFuncFull_WithClosures Source #

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

wrap_EqualFuncFull :: Maybe (Ptr (FunPtr C_EqualFuncFull)) -> EqualFuncFull_WithClosures -> C_EqualFuncFull Source #

Wrap a `EqualFuncFull` into a `C_EqualFuncFull`.

## ErrorClearFunc

type C_ErrorClearFunc = Ptr GError -> IO () Source #

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

type ErrorClearFunc Source #

Arguments

= GError | `error`: extended error to clear
-> IO () |

Specifies the type of function which is called when an extended error instance is freed. It is passed the error pointer about to be freed, and should free the error's private data fields.

Normally, it is better to use `G_DEFINE_EXTENDED_ERROR()`, as it already takes care of getting the private data from `error`.

Since: 2.68

dynamic_ErrorClearFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ErrorClearFunc |
-> GError | `error`: extended error to clear
-> m () |

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

genClosure_ErrorClearFunc :: MonadIO m => ErrorClearFunc -> m (GClosure C_ErrorClearFunc) Source #

Wrap the callback into a `GClosure`.

mk_ErrorClearFunc :: C_ErrorClearFunc -> IO (FunPtr C_ErrorClearFunc) Source #

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

noErrorClearFunc :: Maybe ErrorClearFunc Source #

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

wrap_ErrorClearFunc :: Maybe (Ptr (FunPtr C_ErrorClearFunc)) -> ErrorClearFunc -> C_ErrorClearFunc Source #

Wrap a `ErrorClearFunc` into a `C_ErrorClearFunc`.

## ErrorCopyFunc

type C_ErrorCopyFunc = Ptr GError -> Ptr GError -> IO () Source #

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

type ErrorCopyFunc Source #

Arguments

= GError | `srcError`: source extended error
-> GError | `destError`: destination extended error
-> IO () |

Specifies the type of function which is called when an extended error instance is copied. It is passed the pointer to the destination error and source error, and should copy only the fields of the private data from `srcError` to `destError`.

Normally, it is better to use `G_DEFINE_EXTENDED_ERROR()`, as it already takes care of getting the private data from `srcError` and `destError`.

Since: 2.68

dynamic_ErrorCopyFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ErrorCopyFunc |
-> GError | `srcError`: source extended error
-> GError | `destError`: destination extended error
-> m () |

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

genClosure_ErrorCopyFunc :: MonadIO m => ErrorCopyFunc -> m (GClosure C_ErrorCopyFunc) Source #

Wrap the callback into a `GClosure`.

mk_ErrorCopyFunc :: C_ErrorCopyFunc -> IO (FunPtr C_ErrorCopyFunc) Source #

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

noErrorCopyFunc :: Maybe ErrorCopyFunc Source #

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

wrap_ErrorCopyFunc :: Maybe (Ptr (FunPtr C_ErrorCopyFunc)) -> ErrorCopyFunc -> C_ErrorCopyFunc Source #

Wrap a `ErrorCopyFunc` into a `C_ErrorCopyFunc`.

## ErrorInitFunc

type C_ErrorInitFunc = Ptr GError -> IO () Source #

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

type ErrorInitFunc Source #

Arguments

= GError | `error`: extended error
-> IO () |

Specifies the type of function which is called just after an extended error instance is created and its fields filled. It should only initialize the fields in the private data, which can be received with the generated `*_get_private()` function.

Normally, it is better to use `G_DEFINE_EXTENDED_ERROR()`, as it already takes care of getting the private data from `error`.

Since: 2.68

dynamic_ErrorInitFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ErrorInitFunc |
-> GError | `error`: extended error
-> m () |

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

genClosure_ErrorInitFunc :: MonadIO m => ErrorInitFunc -> m (GClosure C_ErrorInitFunc) Source #

Wrap the callback into a `GClosure`.

mk_ErrorInitFunc :: C_ErrorInitFunc -> IO (FunPtr C_ErrorInitFunc) Source #

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

noErrorInitFunc :: Maybe ErrorInitFunc Source #

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

wrap_ErrorInitFunc :: Maybe (Ptr (FunPtr C_ErrorInitFunc)) -> ErrorInitFunc -> C_ErrorInitFunc Source #

Wrap a `ErrorInitFunc` into a `C_ErrorInitFunc`.

## FreeFunc

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

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

type FreeFunc = IO () Source #

Declares a type of function which takes an arbitrary data pointer argument and has no return value. It is not currently used in GLib or GTK.

type FreeFunc_WithClosures Source #

Arguments

= Ptr () | `data`: a data pointer
-> IO () |

Declares a type of function which takes an arbitrary data pointer argument and has no return value. It is not currently used in GLib or GTK.

drop_closures_FreeFunc :: FreeFunc -> FreeFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FreeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_FreeFunc |
-> Ptr () | `data`: a data pointer
-> m () |

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

genClosure_FreeFunc :: MonadIO m => FreeFunc -> m (GClosure C_FreeFunc) Source #

Wrap the callback into a `GClosure`.

mk_FreeFunc :: C_FreeFunc -> IO (FunPtr C_FreeFunc) Source #

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

noFreeFunc :: Maybe FreeFunc Source #

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

noFreeFunc_WithClosures :: Maybe FreeFunc_WithClosures Source #

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

wrap_FreeFunc :: Maybe (Ptr (FunPtr C_FreeFunc)) -> FreeFunc_WithClosures -> C_FreeFunc Source #

Wrap a `FreeFunc` into a `C_FreeFunc`.

## Func

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

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

type Func Source #

Arguments

= Ptr () | `data`: the element's data
-> IO () |

Specifies the type of functions passed to `g_list_foreach()` and `g_slist_foreach()`.

type Func_WithClosures Source #

Arguments

= Ptr () | `data`: the element's data
-> Ptr () | `userData`: user data passed to `g_list_foreach()` or `g_slist_foreach()`
-> IO () |

Specifies the type of functions passed to `g_list_foreach()` and `g_slist_foreach()`.

drop_closures_Func :: Func -> Func_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_Func Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_Func |
-> Ptr () | `data`: the element's data
-> Ptr () | `userData`: user data passed to `g_list_foreach()` or `g_slist_foreach()`
-> m () |

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

genClosure_Func :: MonadIO m => Func -> m (GClosure C_Func) Source #

Wrap the callback into a `GClosure`.

mk_Func :: C_Func -> IO (FunPtr C_Func) Source #

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

noFunc :: Maybe Func Source #

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

noFunc_WithClosures :: Maybe Func_WithClosures Source #

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

wrap_Func :: Maybe (Ptr (FunPtr C_Func)) -> Func_WithClosures -> C_Func Source #

Wrap a `Func` into a `C_Func`.

## HFunc

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

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

type HFunc Source #

Arguments

= Ptr () | `key`: a key
-> Ptr () | `value`: the value corresponding to the key
-> IO () |

Specifies the type of the function passed to `hashTableForeach`. It is called with each key/value pair, together with the `userData` parameter which is passed to `hashTableForeach`.

type HFunc_WithClosures Source #

Arguments

= Ptr () | `key`: a key
-> Ptr () | `value`: the value corresponding to the key
-> Ptr () | `userData`: user data passed to `hashTableForeach`
-> IO () |

Specifies the type of the function passed to `hashTableForeach`. It is called with each key/value pair, together with the `userData` parameter which is passed to `hashTableForeach`.

drop_closures_HFunc :: HFunc -> HFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_HFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HFunc |
-> Ptr () | `key`: a key
-> Ptr () | `value`: the value corresponding to the key
-> Ptr () | `userData`: user data passed to `hashTableForeach`
-> m () |

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

genClosure_HFunc :: MonadIO m => HFunc -> m (GClosure C_HFunc) Source #

Wrap the callback into a `GClosure`.

mk_HFunc :: C_HFunc -> IO (FunPtr C_HFunc) Source #

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

noHFunc :: Maybe HFunc Source #

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

noHFunc_WithClosures :: Maybe HFunc_WithClosures Source #

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

wrap_HFunc :: Maybe (Ptr (FunPtr C_HFunc)) -> HFunc_WithClosures -> C_HFunc Source #

Wrap a `HFunc` into a `C_HFunc`.

## HRFunc

type C_HRFunc = Ptr () -> Ptr () -> Ptr () -> IO CInt Source #

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

type HRFunc Source #

Arguments

= Ptr () | `key`: a key
-> Ptr () | `value`: the value associated with the key
-> IO Bool | Returns: `True` if the key/value pair should be removed from the `HashTable`

Specifies the type of the function passed to `hashTableForeachRemove`. It is called with each key/value pair, together with the `userData` parameter passed to `hashTableForeachRemove`. It should return `True` if the key/value pair should be removed from the `HashTable`.

type HRFunc_WithClosures Source #

Arguments

= Ptr () | `key`: a key
-> Ptr () | `value`: the value associated with the key
-> Ptr () | `userData`: user data passed to `hashTableRemove`
-> IO Bool | Returns: `True` if the key/value pair should be removed from the `HashTable`

Specifies the type of the function passed to `hashTableForeachRemove`. It is called with each key/value pair, together with the `userData` parameter passed to `hashTableForeachRemove`. It should return `True` if the key/value pair should be removed from the `HashTable`.

drop_closures_HRFunc :: HRFunc -> HRFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_HRFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HRFunc |
-> Ptr () | `key`: a key
-> Ptr () | `value`: the value associated with the key
-> Ptr () | `userData`: user data passed to `hashTableRemove`
-> m Bool | Returns: `True` if the key/value pair should be removed from the `HashTable`

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

genClosure_HRFunc :: MonadIO m => HRFunc -> m (GClosure C_HRFunc) Source #

Wrap the callback into a `GClosure`.

mk_HRFunc :: C_HRFunc -> IO (FunPtr C_HRFunc) Source #

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

noHRFunc :: Maybe HRFunc Source #

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

noHRFunc_WithClosures :: Maybe HRFunc_WithClosures Source #

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

wrap_HRFunc :: Maybe (Ptr (FunPtr C_HRFunc)) -> HRFunc_WithClosures -> C_HRFunc Source #

Wrap a `HRFunc` into a `C_HRFunc`.

## HashFunc

type C_HashFunc = Ptr () -> IO Word32 Source #

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

type HashFunc Source #

Arguments

= IO Word32 | Returns: the hash value corresponding to the key

Specifies the type of the hash function which is passed to `g_hash_table_new()` when a `HashTable` is created.

The function is passed a key and should return a `guint` hash value. The functions `directHash`, `intHash` and `strHash` provide hash functions which can be used when the key is a `gpointer`, `gint`*, and `gchar`* respectively.

`directHash` is also the appropriate hash function for keys of the form `GINT_TO_POINTER (n)` (or similar macros).

A good hash functions should produce hash values that are evenly distributed over a fairly large range. The modulus is taken with the hash table size (a prime number) to find the 'bucket' to place each key into. The function should also be very fast, since it is called for each key lookup.

Note that the hash functions provided by GLib have these qualities, but are not particularly robust against manufactured keys that cause hash collisions. Therefore, you should consider choosing a more secure hash function when using a GHashTable with keys that originate in untrusted data (such as HTTP requests). Using `strHash` in that situation might make your application vulnerable to Algorithmic Complexity Attacks.

The key to choosing a good hash is unpredictability. Even cryptographic hashes are very easy to find collisions for when the remainder is taken modulo a somewhat predictable prime number. There must be an element of randomness that an attacker is unable to guess.

type HashFunc_WithClosures Source #

Arguments

= Ptr () | `key`: a key
-> IO Word32 | Returns: the hash value corresponding to the key

Specifies the type of the hash function which is passed to `g_hash_table_new()` when a `HashTable` is created.

The function is passed a key and should return a `guint` hash value. The functions `directHash`, `intHash` and `strHash` provide hash functions which can be used when the key is a `gpointer`, `gint`*, and `gchar`* respectively.

`directHash` is also the appropriate hash function for keys of the form `GINT_TO_POINTER (n)` (or similar macros).

A good hash functions should produce hash values that are evenly distributed over a fairly large range. The modulus is taken with the hash table size (a prime number) to find the 'bucket' to place each key into. The function should also be very fast, since it is called for each key lookup.

Note that the hash functions provided by GLib have these qualities, but are not particularly robust against manufactured keys that cause hash collisions. Therefore, you should consider choosing a more secure hash function when using a GHashTable with keys that originate in untrusted data (such as HTTP requests). Using `strHash` in that situation might make your application vulnerable to Algorithmic Complexity Attacks.

The key to choosing a good hash is unpredictability. Even cryptographic hashes are very easy to find collisions for when the remainder is taken modulo a somewhat predictable prime number. There must be an element of randomness that an attacker is unable to guess.

drop_closures_HashFunc :: HashFunc -> HashFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_HashFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HashFunc |
-> Ptr () | `key`: a key
-> m Word32 | Returns: the hash value corresponding to the key

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

genClosure_HashFunc :: MonadIO m => HashFunc -> m (GClosure C_HashFunc) Source #

Wrap the callback into a `GClosure`.

mk_HashFunc :: C_HashFunc -> IO (FunPtr C_HashFunc) Source #

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

noHashFunc :: Maybe HashFunc Source #

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

noHashFunc_WithClosures :: Maybe HashFunc_WithClosures Source #

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

wrap_HashFunc :: Maybe (Ptr (FunPtr C_HashFunc)) -> HashFunc_WithClosures -> C_HashFunc Source #

Wrap a `HashFunc` into a `C_HashFunc`.

## HookCheckFunc

type C_HookCheckFunc = Ptr () -> IO CInt Source #

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

type HookCheckFunc Source #

Arguments

= IO Bool | Returns: `False` if the `Hook` should be destroyed

Defines the type of a hook function that can be invoked by `hookListInvokeCheck`.

type HookCheckFunc_WithClosures Source #

Arguments

= Ptr () | `data`: the data field of the `Hook` is passed to the hook function here
-> IO Bool | Returns: `False` if the `Hook` should be destroyed

Defines the type of a hook function that can be invoked by `hookListInvokeCheck`.

drop_closures_HookCheckFunc :: HookCheckFunc -> HookCheckFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_HookCheckFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HookCheckFunc |
-> Ptr () | `data`: the data field of the `Hook` is passed to the hook function here
-> m Bool | Returns: `False` if the `Hook` should be destroyed

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

genClosure_HookCheckFunc :: MonadIO m => HookCheckFunc -> m (GClosure C_HookCheckFunc) Source #

Wrap the callback into a `GClosure`.

mk_HookCheckFunc :: C_HookCheckFunc -> IO (FunPtr C_HookCheckFunc) Source #

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

noHookCheckFunc :: Maybe HookCheckFunc Source #

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

noHookCheckFunc_WithClosures :: Maybe HookCheckFunc_WithClosures Source #

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

wrap_HookCheckFunc :: Maybe (Ptr (FunPtr C_HookCheckFunc)) -> HookCheckFunc_WithClosures -> C_HookCheckFunc Source #

Wrap a `HookCheckFunc` into a `C_HookCheckFunc`.

## HookCheckMarshaller

type C_HookCheckMarshaller = Ptr Hook -> Ptr () -> IO CInt Source #

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

type HookCheckMarshaller Source #

Arguments

= Hook | `hook`: a `Hook`
-> IO Bool | Returns: `False` if `hook` should be destroyed

Defines the type of function used by `hookListMarshalCheck`.

type HookCheckMarshaller_WithClosures Source #

Arguments

= Hook | `hook`: a `Hook`
-> Ptr () | `marshalData`: user data
-> IO Bool | Returns: `False` if `hook` should be destroyed

Defines the type of function used by `hookListMarshalCheck`.

drop_closures_HookCheckMarshaller :: HookCheckMarshaller -> HookCheckMarshaller_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_HookCheckMarshaller Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HookCheckMarshaller |
-> Hook | `hook`: a `Hook`
-> Ptr () | `marshalData`: user data
-> m Bool | Returns: `False` if `hook` should be destroyed

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

genClosure_HookCheckMarshaller :: MonadIO m => HookCheckMarshaller -> m (GClosure C_HookCheckMarshaller) Source #

Wrap the callback into a `GClosure`.

mk_HookCheckMarshaller :: C_HookCheckMarshaller -> IO (FunPtr C_HookCheckMarshaller) Source #

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

noHookCheckMarshaller :: Maybe HookCheckMarshaller Source #

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

noHookCheckMarshaller_WithClosures :: Maybe HookCheckMarshaller_WithClosures Source #

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

wrap_HookCheckMarshaller :: Maybe (Ptr (FunPtr C_HookCheckMarshaller)) -> HookCheckMarshaller_WithClosures -> C_HookCheckMarshaller Source #

Wrap a `HookCheckMarshaller` into a `C_HookCheckMarshaller`.

## HookCompareFunc

type C_HookCompareFunc = Ptr Hook -> Ptr Hook -> IO Int32 Source #

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

type HookCompareFunc Source #

Arguments

= Hook | `newHook`: the `Hook` being inserted
-> Hook | `sibling`: the `Hook` to compare with `newHook`
-> IO Int32 | Returns: a value <= 0 if `newHook` should be before `sibling`

Defines the type of function used to compare `Hook` elements in `hookInsertSorted`.

dynamic_HookCompareFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HookCompareFunc |
-> Hook | `newHook`: the `Hook` being inserted
-> Hook | `sibling`: the `Hook` to compare with `newHook`
-> m Int32 | Returns: a value <= 0 if `newHook` should be before `sibling`

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

genClosure_HookCompareFunc :: MonadIO m => HookCompareFunc -> m (GClosure C_HookCompareFunc) Source #

Wrap the callback into a `GClosure`.

mk_HookCompareFunc :: C_HookCompareFunc -> IO (FunPtr C_HookCompareFunc) Source #

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

noHookCompareFunc :: Maybe HookCompareFunc Source #

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

wrap_HookCompareFunc :: Maybe (Ptr (FunPtr C_HookCompareFunc)) -> HookCompareFunc -> C_HookCompareFunc Source #

Wrap a `HookCompareFunc` into a `C_HookCompareFunc`.

## HookFinalizeFunc

type C_HookFinalizeFunc = Ptr HookList -> Ptr Hook -> IO () Source #

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

type HookFinalizeFunc Source #

Arguments

= HookList | `hookList`: a `HookList`
-> Hook | `hook`: the hook in `hookList` that gets finalized
-> IO () |

Defines the type of function to be called when a hook in a list of hooks gets finalized.

dynamic_HookFinalizeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HookFinalizeFunc |
-> HookList | `hookList`: a `HookList`
-> Hook | `hook`: the hook in `hookList` that gets finalized
-> m () |

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

genClosure_HookFinalizeFunc :: MonadIO m => HookFinalizeFunc -> m (GClosure C_HookFinalizeFunc) Source #

Wrap the callback into a `GClosure`.

mk_HookFinalizeFunc :: C_HookFinalizeFunc -> IO (FunPtr C_HookFinalizeFunc) Source #

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

noHookFinalizeFunc :: Maybe HookFinalizeFunc Source #

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

wrap_HookFinalizeFunc :: Maybe (Ptr (FunPtr C_HookFinalizeFunc)) -> HookFinalizeFunc -> C_HookFinalizeFunc Source #

Wrap a `HookFinalizeFunc` into a `C_HookFinalizeFunc`.

## HookFindFunc

type C_HookFindFunc = Ptr Hook -> Ptr () -> IO CInt Source #

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

type HookFindFunc Source #

Arguments

= Hook | `hook`: a `Hook`
-> IO Bool | Returns: `True` if the required `Hook` has been found

Defines the type of the function passed to `g_hook_find()`.

type HookFindFunc_WithClosures Source #

Arguments

= Hook | `hook`: a `Hook`
-> Ptr () | `data`: user data passed to `g_hook_find_func()`
-> IO Bool | Returns: `True` if the required `Hook` has been found

Defines the type of the function passed to `g_hook_find()`.

drop_closures_HookFindFunc :: HookFindFunc -> HookFindFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_HookFindFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HookFindFunc |
-> Hook | `hook`: a `Hook`
-> Ptr () | `data`: user data passed to `g_hook_find_func()`
-> m Bool | Returns: `True` if the required `Hook` has been found

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

genClosure_HookFindFunc :: MonadIO m => HookFindFunc -> m (GClosure C_HookFindFunc) Source #

Wrap the callback into a `GClosure`.

mk_HookFindFunc :: C_HookFindFunc -> IO (FunPtr C_HookFindFunc) Source #

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

noHookFindFunc :: Maybe HookFindFunc Source #

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

noHookFindFunc_WithClosures :: Maybe HookFindFunc_WithClosures Source #

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

wrap_HookFindFunc :: Maybe (Ptr (FunPtr C_HookFindFunc)) -> HookFindFunc_WithClosures -> C_HookFindFunc Source #

Wrap a `HookFindFunc` into a `C_HookFindFunc`.

## HookFunc

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

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

type HookFunc = IO () Source #

Defines the type of a hook function that can be invoked by `hookListInvoke`.

type HookFunc_WithClosures Source #

Arguments

= Ptr () | `data`: the data field of the `Hook` is passed to the hook function here
-> IO () |

Defines the type of a hook function that can be invoked by `hookListInvoke`.

drop_closures_HookFunc :: HookFunc -> HookFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_HookFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HookFunc |
-> Ptr () | `data`: the data field of the `Hook` is passed to the hook function here
-> m () |

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

genClosure_HookFunc :: MonadIO m => HookFunc -> m (GClosure C_HookFunc) Source #

Wrap the callback into a `GClosure`.

mk_HookFunc :: C_HookFunc -> IO (FunPtr C_HookFunc) Source #

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

noHookFunc :: Maybe HookFunc Source #

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

noHookFunc_WithClosures :: Maybe HookFunc_WithClosures Source #

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

wrap_HookFunc :: Maybe (Ptr (FunPtr C_HookFunc)) -> HookFunc_WithClosures -> C_HookFunc Source #

Wrap a `HookFunc` into a `C_HookFunc`.

## HookMarshaller

type C_HookMarshaller = Ptr Hook -> Ptr () -> IO () Source #

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

type HookMarshaller Source #

Arguments

= Hook | `hook`: a `Hook`
-> IO () |

Defines the type of function used by `hookListMarshal`.

type HookMarshaller_WithClosures Source #

Arguments

= Hook | `hook`: a `Hook`
-> Ptr () | `marshalData`: user data
-> IO () |

Defines the type of function used by `hookListMarshal`.

drop_closures_HookMarshaller :: HookMarshaller -> HookMarshaller_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_HookMarshaller Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_HookMarshaller |
-> Hook | `hook`: a `Hook`
-> Ptr () | `marshalData`: user data
-> m () |

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

genClosure_HookMarshaller :: MonadIO m => HookMarshaller -> m (GClosure C_HookMarshaller) Source #

Wrap the callback into a `GClosure`.

mk_HookMarshaller :: C_HookMarshaller -> IO (FunPtr C_HookMarshaller) Source #

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

noHookMarshaller :: Maybe HookMarshaller Source #

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

noHookMarshaller_WithClosures :: Maybe HookMarshaller_WithClosures Source #

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

wrap_HookMarshaller :: Maybe (Ptr (FunPtr C_HookMarshaller)) -> HookMarshaller_WithClosures -> C_HookMarshaller Source #

Wrap a `HookMarshaller` into a `C_HookMarshaller`.

## IOFunc

type C_IOFunc = Ptr IOChannel -> CUInt -> Ptr () -> IO CInt Source #

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

type IOFunc Source #

Arguments

= IOChannel | `source`: the `IOChannel` event source
-> [IOCondition] | `condition`: the condition which has been satisfied
-> IO Bool | Returns: the function should return `False` if the event source should be removed

Specifies the type of function passed to `g_io_add_watch()` or `ioAddWatch`, which is called when the requested condition on a `IOChannel` is satisfied.

type IOFunc_WithClosures Source #

Arguments

= IOChannel | `source`: the `IOChannel` event source
-> [IOCondition] | `condition`: the condition which has been satisfied
-> Ptr () | `data`: user data set in `g_io_add_watch()` or `ioAddWatch`
-> IO Bool | Returns: the function should return `False` if the event source should be removed

Specifies the type of function passed to `g_io_add_watch()` or `ioAddWatch`, which is called when the requested condition on a `IOChannel` is satisfied.

drop_closures_IOFunc :: IOFunc -> IOFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_IOFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_IOFunc |
-> IOChannel | `source`: the `IOChannel` event source
-> [IOCondition] | `condition`: the condition which has been satisfied
-> Ptr () | `data`: user data set in `g_io_add_watch()` or `ioAddWatch`
-> m Bool | Returns: the function should return `False` if the event source should be removed

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

genClosure_IOFunc :: MonadIO m => IOFunc -> m (GClosure C_IOFunc) Source #

Wrap the callback into a `GClosure`.

mk_IOFunc :: C_IOFunc -> IO (FunPtr C_IOFunc) Source #

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

noIOFunc :: Maybe IOFunc Source #

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

noIOFunc_WithClosures :: Maybe IOFunc_WithClosures Source #

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

wrap_IOFunc :: Maybe (Ptr (FunPtr C_IOFunc)) -> IOFunc_WithClosures -> C_IOFunc Source #

Wrap a `IOFunc` into a `C_IOFunc`.

## IOFuncsIoCloseFieldCallback

type C_IOFuncsIoCloseFieldCallback = Ptr IOChannel -> Ptr (Ptr GError) -> IO CUInt Source #

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

type IOFuncsIoCloseFieldCallback Source #

Arguments

= IOChannel |
-> IO IOStatus | (Can throw `GError`)

No description available in the introspection data.

dynamic_IOFuncsIoCloseFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_IOFuncsIoCloseFieldCallback |
-> IOChannel |
-> m IOStatus | (Can throw `GError`)

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

mk_IOFuncsIoCloseFieldCallback :: C_IOFuncsIoCloseFieldCallback -> IO (FunPtr C_IOFuncsIoCloseFieldCallback) Source #

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

noIOFuncsIoCloseFieldCallback :: Maybe IOFuncsIoCloseFieldCallback Source #

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

## IOFuncsIoCreateWatchFieldCallback

type C_IOFuncsIoCreateWatchFieldCallback = Ptr IOChannel -> CUInt -> IO (Ptr Source) Source #

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

type IOFuncsIoCreateWatchFieldCallback = IOChannel -> [IOCondition] -> IO Source Source #

No description available in the introspection data.

dynamic_IOFuncsIoCreateWatchFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoCreateWatchFieldCallback -> IOChannel -> [IOCondition] -> m Source Source #

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

genClosure_IOFuncsIoCreateWatchFieldCallback :: MonadIO m => IOFuncsIoCreateWatchFieldCallback -> m (GClosure C_IOFuncsIoCreateWatchFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_IOFuncsIoCreateWatchFieldCallback :: C_IOFuncsIoCreateWatchFieldCallback -> IO (FunPtr C_IOFuncsIoCreateWatchFieldCallback) Source #

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

noIOFuncsIoCreateWatchFieldCallback :: Maybe IOFuncsIoCreateWatchFieldCallback Source #

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

wrap_IOFuncsIoCreateWatchFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)) -> IOFuncsIoCreateWatchFieldCallback -> C_IOFuncsIoCreateWatchFieldCallback Source #

Wrap a `IOFuncsIoCreateWatchFieldCallback` into a `C_IOFuncsIoCreateWatchFieldCallback`.

## IOFuncsIoFreeFieldCallback

type C_IOFuncsIoFreeFieldCallback = Ptr IOChannel -> IO () Source #

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

type IOFuncsIoFreeFieldCallback = IOChannel -> IO () Source #

No description available in the introspection data.

dynamic_IOFuncsIoFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoFreeFieldCallback -> IOChannel -> m () Source #

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

genClosure_IOFuncsIoFreeFieldCallback :: MonadIO m => IOFuncsIoFreeFieldCallback -> m (GClosure C_IOFuncsIoFreeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_IOFuncsIoFreeFieldCallback :: C_IOFuncsIoFreeFieldCallback -> IO (FunPtr C_IOFuncsIoFreeFieldCallback) Source #

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

noIOFuncsIoFreeFieldCallback :: Maybe IOFuncsIoFreeFieldCallback Source #

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

wrap_IOFuncsIoFreeFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)) -> IOFuncsIoFreeFieldCallback -> C_IOFuncsIoFreeFieldCallback Source #

Wrap a `IOFuncsIoFreeFieldCallback` into a `C_IOFuncsIoFreeFieldCallback`.

## IOFuncsIoGetFlagsFieldCallback

type C_IOFuncsIoGetFlagsFieldCallback = Ptr IOChannel -> IO CUInt Source #

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

type IOFuncsIoGetFlagsFieldCallback = IOChannel -> IO [IOFlags] Source #

No description available in the introspection data.

dynamic_IOFuncsIoGetFlagsFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoGetFlagsFieldCallback -> IOChannel -> m [IOFlags] Source #

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

genClosure_IOFuncsIoGetFlagsFieldCallback :: MonadIO m => IOFuncsIoGetFlagsFieldCallback -> m (GClosure C_IOFuncsIoGetFlagsFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_IOFuncsIoGetFlagsFieldCallback :: C_IOFuncsIoGetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoGetFlagsFieldCallback) Source #

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

noIOFuncsIoGetFlagsFieldCallback :: Maybe IOFuncsIoGetFlagsFieldCallback Source #

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

wrap_IOFuncsIoGetFlagsFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)) -> IOFuncsIoGetFlagsFieldCallback -> C_IOFuncsIoGetFlagsFieldCallback Source #

Wrap a `IOFuncsIoGetFlagsFieldCallback` into a `C_IOFuncsIoGetFlagsFieldCallback`.

## IOFuncsIoReadFieldCallback

type C_IOFuncsIoReadFieldCallback = Ptr IOChannel -> CString -> Word64 -> Word64 -> Ptr (Ptr GError) -> IO CUInt Source #

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

type IOFuncsIoReadFieldCallback Source #

Arguments

= IOChannel |
-> Text |
-> Word64 |
-> Word64 |
-> IO IOStatus | (Can throw `GError`)

No description available in the introspection data.

dynamic_IOFuncsIoReadFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_IOFuncsIoReadFieldCallback |
-> IOChannel |
-> Text |
-> Word64 |
-> Word64 |
-> m IOStatus | (Can throw `GError`)

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

mk_IOFuncsIoReadFieldCallback :: C_IOFuncsIoReadFieldCallback -> IO (FunPtr C_IOFuncsIoReadFieldCallback) Source #

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

noIOFuncsIoReadFieldCallback :: Maybe IOFuncsIoReadFieldCallback Source #

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

## IOFuncsIoSeekFieldCallback

type C_IOFuncsIoSeekFieldCallback = Ptr IOChannel -> Int64 -> CUInt -> Ptr (Ptr GError) -> IO CUInt Source #

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

type IOFuncsIoSeekFieldCallback Source #

Arguments

= IOChannel |
-> Int64 |
-> SeekType |
-> IO IOStatus | (Can throw `GError`)

No description available in the introspection data.

dynamic_IOFuncsIoSeekFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_IOFuncsIoSeekFieldCallback |
-> IOChannel |
-> Int64 |
-> SeekType |
-> m IOStatus | (Can throw `GError`)

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

mk_IOFuncsIoSeekFieldCallback :: C_IOFuncsIoSeekFieldCallback -> IO (FunPtr C_IOFuncsIoSeekFieldCallback) Source #

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

noIOFuncsIoSeekFieldCallback :: Maybe IOFuncsIoSeekFieldCallback Source #

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

## IOFuncsIoSetFlagsFieldCallback

type C_IOFuncsIoSetFlagsFieldCallback = Ptr IOChannel -> CUInt -> Ptr (Ptr GError) -> IO CUInt Source #

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

type IOFuncsIoSetFlagsFieldCallback Source #

Arguments

= IOChannel |
-> [IOFlags] |
-> IO IOStatus | (Can throw `GError`)

No description available in the introspection data.

dynamic_IOFuncsIoSetFlagsFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_IOFuncsIoSetFlagsFieldCallback |
-> IOChannel |
-> [IOFlags] |
-> m IOStatus | (Can throw `GError`)

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

mk_IOFuncsIoSetFlagsFieldCallback :: C_IOFuncsIoSetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoSetFlagsFieldCallback) Source #

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

noIOFuncsIoSetFlagsFieldCallback :: Maybe IOFuncsIoSetFlagsFieldCallback Source #

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

## IOFuncsIoWriteFieldCallback

type C_IOFuncsIoWriteFieldCallback = Ptr IOChannel -> CString -> Word64 -> Word64 -> Ptr (Ptr GError) -> IO CUInt Source #

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

type IOFuncsIoWriteFieldCallback Source #

Arguments

= IOChannel |
-> Text |
-> Word64 |
-> Word64 |
-> IO IOStatus | (Can throw `GError`)

No description available in the introspection data.

dynamic_IOFuncsIoWriteFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_IOFuncsIoWriteFieldCallback |
-> IOChannel |
-> Text |
-> Word64 |
-> Word64 |
-> m IOStatus | (Can throw `GError`)

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

mk_IOFuncsIoWriteFieldCallback :: C_IOFuncsIoWriteFieldCallback -> IO (FunPtr C_IOFuncsIoWriteFieldCallback) Source #

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

noIOFuncsIoWriteFieldCallback :: Maybe IOFuncsIoWriteFieldCallback Source #

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

## LogFunc

type C_LogFunc = CString -> CInt -> CString -> Ptr () -> IO () Source #

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

type LogFunc Source #

Arguments

= Text | `logDomain`: the log domain of the message
-> [LogLevelFlags] | `logLevel`: the log level of the message (including the fatal and recursion flags)
-> Text | `message`: the message to process
-> IO () |

Specifies the prototype of log handler functions.

The default log handler, `logDefaultHandler`, automatically appends a new-line character to `message` when printing it. It is advised that any custom log handler functions behave similarly, so that logging calls in user code do not need modifying to add a new-line character to the message if the log handler is changed.

This is not used if structured logging is enabled; see Using Structured Logging.

type LogFunc_WithClosures Source #

Arguments

= Text | `logDomain`: the log domain of the message
-> [LogLevelFlags] | `logLevel`: the log level of the message (including the fatal and recursion flags)
-> Text | `message`: the message to process
-> Ptr () | `userData`: user data, set in `logSetHandler`
-> IO () |

Specifies the prototype of log handler functions.

The default log handler, `logDefaultHandler`, automatically appends a new-line character to `message` when printing it. It is advised that any custom log handler functions behave similarly, so that logging calls in user code do not need modifying to add a new-line character to the message if the log handler is changed.

This is not used if structured logging is enabled; see Using Structured Logging.

drop_closures_LogFunc :: LogFunc -> LogFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_LogFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_LogFunc |
-> Text | `logDomain`: the log domain of the message
-> [LogLevelFlags] | `logLevel`: the log level of the message (including the fatal and recursion flags)
-> Text | `message`: the message to process
-> Ptr () | `userData`: user data, set in `logSetHandler`
-> m () |

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

genClosure_LogFunc :: MonadIO m => LogFunc -> m (GClosure C_LogFunc) Source #

Wrap the callback into a `GClosure`.

mk_LogFunc :: C_LogFunc -> IO (FunPtr C_LogFunc) Source #

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

noLogFunc :: Maybe LogFunc Source #

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

noLogFunc_WithClosures :: Maybe LogFunc_WithClosures Source #

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

wrap_LogFunc :: Maybe (Ptr (FunPtr C_LogFunc)) -> LogFunc_WithClosures -> C_LogFunc Source #

Wrap a `LogFunc` into a `C_LogFunc`.

## LogWriterFunc

type C_LogWriterFunc = CInt -> Ptr LogField -> Word64 -> Ptr () -> IO CUInt Source #

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

type LogWriterFunc Source #

Arguments

= [LogLevelFlags] | `logLevel`: log level of the message
-> [LogField] | `fields`: fields forming the message
-> IO LogWriterOutput | Returns: `LogWriterOutputHandled` if the log entry was handled successfully; `LogWriterOutputUnhandled` otherwise

Writer function for log entries. A log entry is a collection of one or more `GLogFields`, using the standard <https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html field names from journal specification>. See `g_log_structured()` for more information.

Writer functions must ignore fields which they do not recognise, unless they can write arbitrary binary output, as field values may be arbitrary binary.

`logLevel` is guaranteed to be included in `fields` as the `PRIORITY` field, but is provided separately for convenience of deciding whether or where to output the log entry.

Writer functions should return `LogWriterOutputHandled` if they handled the log message successfully or if they deliberately ignored it. If there was an error handling the message (for example, if the writer function is meant to send messages to a remote logging server and there is a network error), it should return `LogWriterOutputUnhandled`. This allows writer functions to be chained and fall back to simpler handlers in case of failure.

Since: 2.50

type LogWriterFunc_WithClosures Source #

Arguments

= [LogLevelFlags] | `logLevel`: log level of the message
-> [LogField] | `fields`: fields forming the message
-> Ptr () | `userData`: user data passed to `logSetWriterFunc`
-> IO LogWriterOutput | Returns: `LogWriterOutputHandled` if the log entry was handled successfully; `LogWriterOutputUnhandled` otherwise

Writer function for log entries. A log entry is a collection of one or more `GLogFields`, using the standard <https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html field names from journal specification>. See `g_log_structured()` for more information.

Writer functions must ignore fields which they do not recognise, unless they can write arbitrary binary output, as field values may be arbitrary binary.

`logLevel` is guaranteed to be included in `fields` as the `PRIORITY` field, but is provided separately for convenience of deciding whether or where to output the log entry.

Writer functions should return `LogWriterOutputHandled` if they handled the log message successfully or if they deliberately ignored it. If there was an error handling the message (for example, if the writer function is meant to send messages to a remote logging server and there is a network error), it should return `LogWriterOutputUnhandled`. This allows writer functions to be chained and fall back to simpler handlers in case of failure.

Since: 2.50

drop_closures_LogWriterFunc :: LogWriterFunc -> LogWriterFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_LogWriterFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_LogWriterFunc |
-> [LogLevelFlags] | `logLevel`: log level of the message
-> [LogField] | `fields`: fields forming the message
-> Ptr () | `userData`: user data passed to `logSetWriterFunc`
-> m LogWriterOutput | Returns: `LogWriterOutputHandled` if the log entry was handled successfully; `LogWriterOutputUnhandled` otherwise

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

genClosure_LogWriterFunc :: MonadIO m => LogWriterFunc -> m (GClosure C_LogWriterFunc) Source #

Wrap the callback into a `GClosure`.

mk_LogWriterFunc :: C_LogWriterFunc -> IO (FunPtr C_LogWriterFunc) Source #

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

noLogWriterFunc :: Maybe LogWriterFunc Source #

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

noLogWriterFunc_WithClosures :: Maybe LogWriterFunc_WithClosures Source #

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

wrap_LogWriterFunc :: Maybe (Ptr (FunPtr C_LogWriterFunc)) -> LogWriterFunc_WithClosures -> C_LogWriterFunc Source #

Wrap a `LogWriterFunc` into a `C_LogWriterFunc`.

## MarkupParserEndElementFieldCallback

type C_MarkupParserEndElementFieldCallback = Ptr MarkupParseContext -> CString -> Ptr () -> Ptr (Ptr GError) -> IO () Source #

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

type MarkupParserEndElementFieldCallback Source #

Arguments

= MarkupParseContext |
-> Text |
-> IO () | (Can throw `GError`)

No description available in the introspection data.

type MarkupParserEndElementFieldCallback_WithClosures Source #

Arguments

= MarkupParseContext |
-> Text |
-> Ptr () |
-> IO () | (Can throw `GError`)

No description available in the introspection data.

drop_closures_MarkupParserEndElementFieldCallback :: MarkupParserEndElementFieldCallback -> MarkupParserEndElementFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserEndElementFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_MarkupParserEndElementFieldCallback |
-> MarkupParseContext |
-> Text |
-> Ptr () |
-> m () | (Can throw `GError`)

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

mk_MarkupParserEndElementFieldCallback :: C_MarkupParserEndElementFieldCallback -> IO (FunPtr C_MarkupParserEndElementFieldCallback) Source #

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

noMarkupParserEndElementFieldCallback :: Maybe MarkupParserEndElementFieldCallback Source #

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

noMarkupParserEndElementFieldCallback_WithClosures :: Maybe MarkupParserEndElementFieldCallback_WithClosures Source #

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

## MarkupParserErrorFieldCallback

type C_MarkupParserErrorFieldCallback = Ptr MarkupParseContext -> Ptr GError -> Ptr () -> IO () Source #

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

type MarkupParserErrorFieldCallback = MarkupParseContext -> GError -> IO () Source #

No description available in the introspection data.

type MarkupParserErrorFieldCallback_WithClosures = MarkupParseContext -> GError -> Ptr () -> IO () Source #

No description available in the introspection data.

drop_closures_MarkupParserErrorFieldCallback :: MarkupParserErrorFieldCallback -> MarkupParserErrorFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserErrorFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MarkupParserErrorFieldCallback -> MarkupParseContext -> GError -> Ptr () -> m () Source #

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

genClosure_MarkupParserErrorFieldCallback :: MonadIO m => MarkupParserErrorFieldCallback -> m (GClosure C_MarkupParserErrorFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_MarkupParserErrorFieldCallback :: C_MarkupParserErrorFieldCallback -> IO (FunPtr C_MarkupParserErrorFieldCallback) Source #

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

noMarkupParserErrorFieldCallback :: Maybe MarkupParserErrorFieldCallback Source #

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

noMarkupParserErrorFieldCallback_WithClosures :: Maybe MarkupParserErrorFieldCallback_WithClosures Source #

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

wrap_MarkupParserErrorFieldCallback :: Maybe (Ptr (FunPtr C_MarkupParserErrorFieldCallback)) -> MarkupParserErrorFieldCallback_WithClosures -> C_MarkupParserErrorFieldCallback Source #

Wrap a `MarkupParserErrorFieldCallback` into a `C_MarkupParserErrorFieldCallback`.

## MarkupParserPassthroughFieldCallback

type C_MarkupParserPassthroughFieldCallback = Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> Ptr (Ptr GError) -> IO () Source #

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

type MarkupParserPassthroughFieldCallback Source #

Arguments

= MarkupParseContext |
-> Text |
-> Word64 |
-> IO () | (Can throw `GError`)

No description available in the introspection data.

type MarkupParserPassthroughFieldCallback_WithClosures Source #

Arguments

= MarkupParseContext |
-> Text |
-> Word64 |
-> Ptr () |
-> IO () | (Can throw `GError`)

No description available in the introspection data.

drop_closures_MarkupParserPassthroughFieldCallback :: MarkupParserPassthroughFieldCallback -> MarkupParserPassthroughFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserPassthroughFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_MarkupParserPassthroughFieldCallback |
-> MarkupParseContext |
-> Text |
-> Word64 |
-> Ptr () |
-> m () | (Can throw `GError`)

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

mk_MarkupParserPassthroughFieldCallback :: C_MarkupParserPassthroughFieldCallback -> IO (FunPtr C_MarkupParserPassthroughFieldCallback) Source #

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

noMarkupParserPassthroughFieldCallback :: Maybe MarkupParserPassthroughFieldCallback Source #

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

noMarkupParserPassthroughFieldCallback_WithClosures :: Maybe MarkupParserPassthroughFieldCallback_WithClosures Source #

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

## MarkupParserStartElementFieldCallback

type C_MarkupParserStartElementFieldCallback = Ptr MarkupParseContext -> CString -> CString -> CString -> Ptr () -> Ptr (Ptr GError) -> IO () Source #

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

type MarkupParserStartElementFieldCallback Source #

Arguments

= MarkupParseContext |
-> Text |
-> Text |
-> Text |
-> IO () | (Can throw `GError`)

No description available in the introspection data.

type MarkupParserStartElementFieldCallback_WithClosures Source #

Arguments

= MarkupParseContext |
-> Text |
-> Text |
-> Text |
-> Ptr () |
-> IO () | (Can throw `GError`)

No description available in the introspection data.

drop_closures_MarkupParserStartElementFieldCallback :: MarkupParserStartElementFieldCallback -> MarkupParserStartElementFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserStartElementFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_MarkupParserStartElementFieldCallback |
-> MarkupParseContext |
-> Text |
-> Text |
-> Text |
-> Ptr () |
-> m () | (Can throw `GError`)

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

mk_MarkupParserStartElementFieldCallback :: C_MarkupParserStartElementFieldCallback -> IO (FunPtr C_MarkupParserStartElementFieldCallback) Source #

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

noMarkupParserStartElementFieldCallback :: Maybe MarkupParserStartElementFieldCallback Source #

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

noMarkupParserStartElementFieldCallback_WithClosures :: Maybe MarkupParserStartElementFieldCallback_WithClosures Source #

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

## MarkupParserTextFieldCallback

type C_MarkupParserTextFieldCallback = Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> Ptr (Ptr GError) -> IO () Source #

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

type MarkupParserTextFieldCallback Source #

Arguments

= MarkupParseContext |
-> Text |
-> Word64 |
-> IO () | (Can throw `GError`)

No description available in the introspection data.

type MarkupParserTextFieldCallback_WithClosures Source #

Arguments

= MarkupParseContext |
-> Text |
-> Word64 |
-> Ptr () |
-> IO () | (Can throw `GError`)

No description available in the introspection data.

drop_closures_MarkupParserTextFieldCallback :: MarkupParserTextFieldCallback -> MarkupParserTextFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserTextFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_MarkupParserTextFieldCallback |
-> MarkupParseContext |
-> Text |
-> Word64 |
-> Ptr () |
-> m () | (Can throw `GError`)

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

mk_MarkupParserTextFieldCallback :: C_MarkupParserTextFieldCallback -> IO (FunPtr C_MarkupParserTextFieldCallback) Source #

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

noMarkupParserTextFieldCallback :: Maybe MarkupParserTextFieldCallback Source #

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

noMarkupParserTextFieldCallback_WithClosures :: Maybe MarkupParserTextFieldCallback_WithClosures Source #

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

## MemVTableCallocFieldCallback

type C_MemVTableCallocFieldCallback = Word64 -> Word64 -> IO (Ptr ()) Source #

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

type MemVTableCallocFieldCallback = Word64 -> Word64 -> IO (Ptr ()) Source #

No description available in the introspection data.

dynamic_MemVTableCallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableCallocFieldCallback -> Word64 -> Word64 -> m (Ptr ()) Source #

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

genClosure_MemVTableCallocFieldCallback :: MonadIO m => MemVTableCallocFieldCallback -> m (GClosure C_MemVTableCallocFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_MemVTableCallocFieldCallback :: C_MemVTableCallocFieldCallback -> IO (FunPtr C_MemVTableCallocFieldCallback) Source #

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

noMemVTableCallocFieldCallback :: Maybe MemVTableCallocFieldCallback Source #

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

wrap_MemVTableCallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableCallocFieldCallback)) -> MemVTableCallocFieldCallback -> C_MemVTableCallocFieldCallback Source #

Wrap a `MemVTableCallocFieldCallback` into a `C_MemVTableCallocFieldCallback`.

## MemVTableFreeFieldCallback

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

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

type MemVTableFreeFieldCallback = IO () Source #

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_MemVTableFreeFieldCallback :: MemVTableFreeFieldCallback -> MemVTableFreeFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_MemVTableFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableFreeFieldCallback -> Ptr () -> m () Source #

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

genClosure_MemVTableFreeFieldCallback :: MonadIO m => MemVTableFreeFieldCallback -> m (GClosure C_MemVTableFreeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_MemVTableFreeFieldCallback :: C_MemVTableFreeFieldCallback -> IO (FunPtr C_MemVTableFreeFieldCallback) Source #

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

noMemVTableFreeFieldCallback :: Maybe MemVTableFreeFieldCallback Source #

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

noMemVTableFreeFieldCallback_WithClosures :: Maybe MemVTableFreeFieldCallback_WithClosures Source #

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

wrap_MemVTableFreeFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableFreeFieldCallback)) -> MemVTableFreeFieldCallback_WithClosures -> C_MemVTableFreeFieldCallback Source #

Wrap a `MemVTableFreeFieldCallback` into a `C_MemVTableFreeFieldCallback`.

## MemVTableMallocFieldCallback

type C_MemVTableMallocFieldCallback = Word64 -> IO (Ptr ()) Source #

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

type MemVTableMallocFieldCallback = Word64 -> IO (Ptr ()) Source #

No description available in the introspection data.

dynamic_MemVTableMallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableMallocFieldCallback -> Word64 -> m (Ptr ()) Source #

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

genClosure_MemVTableMallocFieldCallback :: MonadIO m => MemVTableMallocFieldCallback -> m (GClosure C_MemVTableMallocFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_MemVTableMallocFieldCallback :: C_MemVTableMallocFieldCallback -> IO (FunPtr C_MemVTableMallocFieldCallback) Source #

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

noMemVTableMallocFieldCallback :: Maybe MemVTableMallocFieldCallback Source #

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

wrap_MemVTableMallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableMallocFieldCallback)) -> MemVTableMallocFieldCallback -> C_MemVTableMallocFieldCallback Source #

Wrap a `MemVTableMallocFieldCallback` into a `C_MemVTableMallocFieldCallback`.

## MemVTableReallocFieldCallback

type C_MemVTableReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ()) Source #

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

type MemVTableReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ()) Source #

No description available in the introspection data.

dynamic_MemVTableReallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableReallocFieldCallback -> Ptr () -> Word64 -> m (Ptr ()) Source #

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

genClosure_MemVTableReallocFieldCallback :: MonadIO m => MemVTableReallocFieldCallback -> m (GClosure C_MemVTableReallocFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_MemVTableReallocFieldCallback :: C_MemVTableReallocFieldCallback -> IO (FunPtr C_MemVTableReallocFieldCallback) Source #

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

noMemVTableReallocFieldCallback :: Maybe MemVTableReallocFieldCallback Source #

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

wrap_MemVTableReallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableReallocFieldCallback)) -> MemVTableReallocFieldCallback -> C_MemVTableReallocFieldCallback Source #

Wrap a `MemVTableReallocFieldCallback` into a `C_MemVTableReallocFieldCallback`.

## MemVTableTryMallocFieldCallback

type C_MemVTableTryMallocFieldCallback = Word64 -> IO (Ptr ()) Source #

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

type MemVTableTryMallocFieldCallback = Word64 -> IO (Ptr ()) Source #

No description available in the introspection data.

dynamic_MemVTableTryMallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableTryMallocFieldCallback -> Word64 -> m (Ptr ()) Source #

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

genClosure_MemVTableTryMallocFieldCallback :: MonadIO m => MemVTableTryMallocFieldCallback -> m (GClosure C_MemVTableTryMallocFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_MemVTableTryMallocFieldCallback :: C_MemVTableTryMallocFieldCallback -> IO (FunPtr C_MemVTableTryMallocFieldCallback) Source #

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

noMemVTableTryMallocFieldCallback :: Maybe MemVTableTryMallocFieldCallback Source #

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

wrap_MemVTableTryMallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableTryMallocFieldCallback)) -> MemVTableTryMallocFieldCallback -> C_MemVTableTryMallocFieldCallback Source #

Wrap a `MemVTableTryMallocFieldCallback` into a `C_MemVTableTryMallocFieldCallback`.

## MemVTableTryReallocFieldCallback

type C_MemVTableTryReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ()) Source #

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

type MemVTableTryReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ()) Source #

No description available in the introspection data.

dynamic_MemVTableTryReallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableTryReallocFieldCallback -> Ptr () -> Word64 -> m (Ptr ()) Source #

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

genClosure_MemVTableTryReallocFieldCallback :: MonadIO m => MemVTableTryReallocFieldCallback -> m (GClosure C_MemVTableTryReallocFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_MemVTableTryReallocFieldCallback :: C_MemVTableTryReallocFieldCallback -> IO (FunPtr C_MemVTableTryReallocFieldCallback) Source #

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

noMemVTableTryReallocFieldCallback :: Maybe MemVTableTryReallocFieldCallback Source #

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

wrap_MemVTableTryReallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableTryReallocFieldCallback)) -> MemVTableTryReallocFieldCallback -> C_MemVTableTryReallocFieldCallback Source #

Wrap a `MemVTableTryReallocFieldCallback` into a `C_MemVTableTryReallocFieldCallback`.

## NodeForeachFunc

type C_NodeForeachFunc = Ptr Node -> Ptr () -> IO () Source #

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

type NodeForeachFunc Source #

Arguments

= Node | `node`: a `Node`.
-> IO () |

Specifies the type of function passed to `nodeChildrenForeach`. The function is called with each child node, together with the user data passed to `nodeChildrenForeach`.

type NodeForeachFunc_WithClosures Source #

Arguments

= Node | `node`: a `Node`.
-> Ptr () | `data`: user data passed to `nodeChildrenForeach`.
-> IO () |

Specifies the type of function passed to `nodeChildrenForeach`. The function is called with each child node, together with the user data passed to `nodeChildrenForeach`.

drop_closures_NodeForeachFunc :: NodeForeachFunc -> NodeForeachFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_NodeForeachFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_NodeForeachFunc |
-> Node | `node`: a `Node`.
-> Ptr () | `data`: user data passed to `nodeChildrenForeach`.
-> m () |

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

genClosure_NodeForeachFunc :: MonadIO m => NodeForeachFunc -> m (GClosure C_NodeForeachFunc) Source #

Wrap the callback into a `GClosure`.

mk_NodeForeachFunc :: C_NodeForeachFunc -> IO (FunPtr C_NodeForeachFunc) Source #

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

noNodeForeachFunc :: Maybe NodeForeachFunc Source #

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

noNodeForeachFunc_WithClosures :: Maybe NodeForeachFunc_WithClosures Source #

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

wrap_NodeForeachFunc :: Maybe (Ptr (FunPtr C_NodeForeachFunc)) -> NodeForeachFunc_WithClosures -> C_NodeForeachFunc Source #

Wrap a `NodeForeachFunc` into a `C_NodeForeachFunc`.

## NodeTraverseFunc

type C_NodeTraverseFunc = Ptr Node -> Ptr () -> IO CInt Source #

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

type NodeTraverseFunc Source #

Arguments

= Node | `node`: a `Node`.
-> IO Bool | Returns: `True` to stop the traversal.

Specifies the type of function passed to `nodeTraverse`. The function is called with each of the nodes visited, together with the user data passed to `nodeTraverse`. If the function returns `True`, then the traversal is stopped.

type NodeTraverseFunc_WithClosures Source #

Arguments

= Node | `node`: a `Node`.
-> Ptr () | `data`: user data passed to `nodeTraverse`.
-> IO Bool | Returns: `True` to stop the traversal.

Specifies the type of function passed to `nodeTraverse`. The function is called with each of the nodes visited, together with the user data passed to `nodeTraverse`. If the function returns `True`, then the traversal is stopped.

drop_closures_NodeTraverseFunc :: NodeTraverseFunc -> NodeTraverseFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_NodeTraverseFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_NodeTraverseFunc |
-> Node | `node`: a `Node`.
-> Ptr () | `data`: user data passed to `nodeTraverse`.
-> m Bool | Returns: `True` to stop the traversal.

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

genClosure_NodeTraverseFunc :: MonadIO m => NodeTraverseFunc -> m (GClosure C_NodeTraverseFunc) Source #

Wrap the callback into a `GClosure`.

mk_NodeTraverseFunc :: C_NodeTraverseFunc -> IO (FunPtr C_NodeTraverseFunc) Source #

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

noNodeTraverseFunc :: Maybe NodeTraverseFunc Source #

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

noNodeTraverseFunc_WithClosures :: Maybe NodeTraverseFunc_WithClosures Source #

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

wrap_NodeTraverseFunc :: Maybe (Ptr (FunPtr C_NodeTraverseFunc)) -> NodeTraverseFunc_WithClosures -> C_NodeTraverseFunc Source #

Wrap a `NodeTraverseFunc` into a `C_NodeTraverseFunc`.

## OptionArgFunc

type C_OptionArgFunc = CString -> CString -> Ptr () -> Ptr (Ptr GError) -> IO CInt Source #

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

type OptionArgFunc Source #

Arguments

= Text | `optionName`: The name of the option being parsed. This will be either a single dash followed by a single letter (for a short name) or two dashes followed by a long option name.
-> Text | `value`: The value to be parsed.
-> IO () | Returns: `True` if the option was successfully parsed, `False` if an error occurred, in which case `error` should be set with `g_set_error()` (Can throw `GError`)

The type of function to be passed as callback for `OptionArgCallback` options.

type OptionArgFunc_WithClosures Source #

Arguments

= Text | `optionName`: The name of the option being parsed. This will be either a single dash followed by a single letter (for a short name) or two dashes followed by a long option name.
-> Text | `value`: The value to be parsed.
-> Ptr () | `data`: User data added to the `OptionGroup` containing the option when it was created with `optionGroupNew`
-> IO () | Returns: `True` if the option was successfully parsed, `False` if an error occurred, in which case `error` should be set with `g_set_error()` (Can throw `GError`)

The type of function to be passed as callback for `OptionArgCallback` options.

drop_closures_OptionArgFunc :: OptionArgFunc -> OptionArgFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_OptionArgFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_OptionArgFunc |
-> Text | `optionName`: The name of the option being parsed. This will be either a single dash followed by a single letter (for a short name) or two dashes followed by a long option name.
-> Text | `value`: The value to be parsed.
-> Ptr () | `data`: User data added to the `OptionGroup` containing the option when it was created with `optionGroupNew`
-> m () | (Can throw `GError`)

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

mk_OptionArgFunc :: C_OptionArgFunc -> IO (FunPtr C_OptionArgFunc) Source #

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

noOptionArgFunc :: Maybe OptionArgFunc Source #

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

noOptionArgFunc_WithClosures :: Maybe OptionArgFunc_WithClosures Source #

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

## OptionErrorFunc

type C_OptionErrorFunc = Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> Ptr (Ptr GError) -> IO () Source #

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

type OptionErrorFunc Source #

Arguments

= OptionContext | `context`: The active `OptionContext`
-> OptionGroup | `group`: The group to which the function belongs
-> IO () | (Can throw `GError`)

The type of function to be used as callback when a parse error occurs.

type OptionErrorFunc_WithClosures Source #

Arguments

= OptionContext | `context`: The active `OptionContext`
-> OptionGroup | `group`: The group to which the function belongs
-> Ptr () | `data`: User data added to the `OptionGroup` containing the option when it was created with `optionGroupNew`
-> IO () | (Can throw `GError`)

The type of function to be used as callback when a parse error occurs.

drop_closures_OptionErrorFunc :: OptionErrorFunc -> OptionErrorFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_OptionErrorFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_OptionErrorFunc |
-> OptionContext | `context`: The active `OptionContext`
-> OptionGroup | `group`: The group to which the function belongs
-> Ptr () | `data`: User data added to the `OptionGroup` containing the option when it was created with `optionGroupNew`
-> m () | (Can throw `GError`)

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

mk_OptionErrorFunc :: C_OptionErrorFunc -> IO (FunPtr C_OptionErrorFunc) Source #

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

noOptionErrorFunc :: Maybe OptionErrorFunc Source #

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

noOptionErrorFunc_WithClosures :: Maybe OptionErrorFunc_WithClosures Source #

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

## OptionParseFunc

type C_OptionParseFunc = Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> Ptr (Ptr GError) -> IO CInt Source #

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

type OptionParseFunc Source #

Arguments

= OptionContext | `context`: The active `OptionContext`
-> OptionGroup | `group`: The group to which the function belongs
-> IO () | Returns: `True` if the function completed successfully, `False` if an error occurred, in which case `error` should be set with `g_set_error()` (Can throw `GError`)

The type of function that can be called before and after parsing.

type OptionParseFunc_WithClosures Source #

Arguments

= OptionContext | `context`: The active `OptionContext`
-> OptionGroup | `group`: The group to which the function belongs
-> Ptr () | `data`: User data added to the `OptionGroup` containing the option when it was created with `optionGroupNew`
-> IO () | Returns: `True` if the function completed successfully, `False` if an error occurred, in which case `error` should be set with `g_set_error()` (Can throw `GError`)

The type of function that can be called before and after parsing.

drop_closures_OptionParseFunc :: OptionParseFunc -> OptionParseFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_OptionParseFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_OptionParseFunc |
-> OptionContext | `context`: The active `OptionContext`
-> OptionGroup | `group`: The group to which the function belongs
-> Ptr () | `data`: User data added to the `OptionGroup` containing the option when it was created with `optionGroupNew`
-> m () | (Can throw `GError`)

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

mk_OptionParseFunc :: C_OptionParseFunc -> IO (FunPtr C_OptionParseFunc) Source #

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

noOptionParseFunc :: Maybe OptionParseFunc Source #

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

noOptionParseFunc_WithClosures :: Maybe OptionParseFunc_WithClosures Source #

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

## PollFunc

type C_PollFunc = Ptr PollFD -> Word32 -> Int32 -> IO Int32 Source #

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

type PollFunc Source #

Arguments

= PollFD | `ufds`: an array of `PollFD` elements
-> Word32 | `nfsd`: the number of elements in `ufds`
-> Int32 | `timeout_`: the maximum time to wait for an event of the file descriptors. A negative value indicates an infinite timeout.
-> IO Int32 | Returns: the number of `PollFD` elements which have events or errors reported, or -1 if an error occurred.

Specifies the type of function passed to `g_main_context_set_poll_func()`. The semantics of the function should match those of the `poll()` system call.

dynamic_PollFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_PollFunc |
-> PollFD | `ufds`: an array of `PollFD` elements
-> Word32 | `nfsd`: the number of elements in `ufds`
-> Int32 | `timeout_`: the maximum time to wait for an event of the file descriptors. A negative value indicates an infinite timeout.
-> m Int32 | Returns: the number of `PollFD` elements which have events or errors reported, or -1 if an error occurred.

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

genClosure_PollFunc :: MonadIO m => PollFunc -> m (GClosure C_PollFunc) Source #

Wrap the callback into a `GClosure`.

mk_PollFunc :: C_PollFunc -> IO (FunPtr C_PollFunc) Source #

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

noPollFunc :: Maybe PollFunc Source #

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

wrap_PollFunc :: Maybe (Ptr (FunPtr C_PollFunc)) -> PollFunc -> C_PollFunc Source #

Wrap a `PollFunc` into a `C_PollFunc`.

## PrintFunc

type C_PrintFunc = CString -> IO () Source #

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

type PrintFunc Source #

Arguments

= Text | `string`: the message to output
-> IO () |

Specifies the type of the print handler functions. These are called with the complete formatted string to output.

dynamic_PrintFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_PrintFunc |
-> Text | `string`: the message to output
-> m () |

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

genClosure_PrintFunc :: MonadIO m => PrintFunc -> m (GClosure C_PrintFunc) Source #

Wrap the callback into a `GClosure`.

mk_PrintFunc :: C_PrintFunc -> IO (FunPtr C_PrintFunc) Source #

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

noPrintFunc :: Maybe PrintFunc Source #

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

wrap_PrintFunc :: Maybe (Ptr (FunPtr C_PrintFunc)) -> PrintFunc -> C_PrintFunc Source #

Wrap a `PrintFunc` into a `C_PrintFunc`.

## RegexEvalCallback

type C_RegexEvalCallback = Ptr MatchInfo -> Ptr String -> Ptr () -> IO CInt Source #

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

type RegexEvalCallback Source #

Arguments

= MatchInfo | `matchInfo`: the `MatchInfo` generated by the match. Use `matchInfoGetRegex` and `matchInfoGetString` if you need the `Regex` or the matched string.
-> String | `result`: a `String` containing the new string
-> IO Bool | Returns: `False` to continue the replacement process, `True` to stop it

Specifies the type of the function passed to `regexReplaceEval`. It is called for each occurrence of the pattern in the string passed to `regexReplaceEval`, and it should append the replacement to `result`.

Since: 2.14

type RegexEvalCallback_WithClosures Source #

Arguments

= MatchInfo | `matchInfo`: the `MatchInfo` generated by the match. Use `matchInfoGetRegex` and `matchInfoGetString` if you need the `Regex` or the matched string.
-> String | `result`: a `String` containing the new string
-> Ptr () | `userData`: user data passed to `regexReplaceEval`
-> IO Bool | Returns: `False` to continue the replacement process, `True` to stop it

Specifies the type of the function passed to `regexReplaceEval`. It is called for each occurrence of the pattern in the string passed to `regexReplaceEval`, and it should append the replacement to `result`.

Since: 2.14

drop_closures_RegexEvalCallback :: RegexEvalCallback -> RegexEvalCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_RegexEvalCallback Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_RegexEvalCallback |
-> MatchInfo | `matchInfo`: the `MatchInfo` generated by the match. Use `matchInfoGetRegex` and `matchInfoGetString` if you need the `Regex` or the matched string.
-> String | `result`: a `String` containing the new string
-> Ptr () | `userData`: user data passed to `regexReplaceEval`
-> m Bool | Returns: `False` to continue the replacement process, `True` to stop it

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

genClosure_RegexEvalCallback :: MonadIO m => RegexEvalCallback -> m (GClosure C_RegexEvalCallback) Source #

Wrap the callback into a `GClosure`.

mk_RegexEvalCallback :: C_RegexEvalCallback -> IO (FunPtr C_RegexEvalCallback) Source #

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

noRegexEvalCallback :: Maybe RegexEvalCallback Source #

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

noRegexEvalCallback_WithClosures :: Maybe RegexEvalCallback_WithClosures Source #

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

wrap_RegexEvalCallback :: Maybe (Ptr (FunPtr C_RegexEvalCallback)) -> RegexEvalCallback_WithClosures -> C_RegexEvalCallback Source #

Wrap a `RegexEvalCallback` into a `C_RegexEvalCallback`.

## ScannerMsgFunc

type C_ScannerMsgFunc = Ptr Scanner -> CString -> CInt -> IO () Source #

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

type ScannerMsgFunc Source #

Arguments

= Scanner | `scanner`: a `Scanner`
-> Text | `message`: the message
-> Bool | `error`: `True` if the message signals an error, `False` if it signals a warning.
-> IO () |

Specifies the type of the message handler function.

dynamic_ScannerMsgFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ScannerMsgFunc |
-> Scanner | `scanner`: a `Scanner`
-> Text | `message`: the message
-> Bool | `error`: `True` if the message signals an error, `False` if it signals a warning.
-> m () |

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

genClosure_ScannerMsgFunc :: MonadIO m => ScannerMsgFunc -> m (GClosure C_ScannerMsgFunc) Source #

Wrap the callback into a `GClosure`.

mk_ScannerMsgFunc :: C_ScannerMsgFunc -> IO (FunPtr C_ScannerMsgFunc) Source #

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

noScannerMsgFunc :: Maybe ScannerMsgFunc Source #

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

wrap_ScannerMsgFunc :: Maybe (Ptr (FunPtr C_ScannerMsgFunc)) -> ScannerMsgFunc -> C_ScannerMsgFunc Source #

Wrap a `ScannerMsgFunc` into a `C_ScannerMsgFunc`.

## SequenceIterCompareFunc

type C_SequenceIterCompareFunc = Ptr SequenceIter -> Ptr SequenceIter -> Ptr () -> IO Int32 Source #

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

type SequenceIterCompareFunc Source #

Arguments

= SequenceIter | `a`: a `SequenceIter`
-> SequenceIter | `b`: a `SequenceIter`
-> IO Int32 | Returns: zero if the iterators are equal, a negative value if `a` comes before `b`, and a positive value if `b` comes before `a`.

A `SequenceIterCompareFunc` is a function used to compare iterators. It must return zero if the iterators compare equal, a negative value if `a` comes before `b`, and a positive value if `b` comes before `a`.

type SequenceIterCompareFunc_WithClosures Source #

Arguments

= SequenceIter | `a`: a `SequenceIter`
-> SequenceIter | `b`: a `SequenceIter`
-> Ptr () | `data`: user data
-> IO Int32 | Returns: zero if the iterators are equal, a negative value if `a` comes before `b`, and a positive value if `b` comes before `a`.

A `SequenceIterCompareFunc` is a function used to compare iterators. It must return zero if the iterators compare equal, a negative value if `a` comes before `b`, and a positive value if `b` comes before `a`.

drop_closures_SequenceIterCompareFunc :: SequenceIterCompareFunc -> SequenceIterCompareFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SequenceIterCompareFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_SequenceIterCompareFunc |
-> SequenceIter | `a`: a `SequenceIter`
-> SequenceIter | `b`: a `SequenceIter`
-> Ptr () | `data`: user data
-> m Int32 | Returns: zero if the iterators are equal, a negative value if `a` comes before `b`, and a positive value if `b` comes before `a`.

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

genClosure_SequenceIterCompareFunc :: MonadIO m => SequenceIterCompareFunc -> m (GClosure C_SequenceIterCompareFunc) Source #

Wrap the callback into a `GClosure`.

mk_SequenceIterCompareFunc :: C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc) Source #

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

noSequenceIterCompareFunc :: Maybe SequenceIterCompareFunc Source #

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

noSequenceIterCompareFunc_WithClosures :: Maybe SequenceIterCompareFunc_WithClosures Source #

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

wrap_SequenceIterCompareFunc :: Maybe (Ptr (FunPtr C_SequenceIterCompareFunc)) -> SequenceIterCompareFunc_WithClosures -> C_SequenceIterCompareFunc Source #

Wrap a `SequenceIterCompareFunc` into a `C_SequenceIterCompareFunc`.

## SourceCallbackFuncsRefFieldCallback

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

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

type SourceCallbackFuncsRefFieldCallback = IO () Source #

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_SourceCallbackFuncsRefFieldCallback :: SourceCallbackFuncsRefFieldCallback -> SourceCallbackFuncsRefFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SourceCallbackFuncsRefFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceCallbackFuncsRefFieldCallback -> Ptr () -> m () Source #

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

genClosure_SourceCallbackFuncsRefFieldCallback :: MonadIO m => SourceCallbackFuncsRefFieldCallback -> m (GClosure C_SourceCallbackFuncsRefFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_SourceCallbackFuncsRefFieldCallback :: C_SourceCallbackFuncsRefFieldCallback -> IO (FunPtr C_SourceCallbackFuncsRefFieldCallback) Source #

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

noSourceCallbackFuncsRefFieldCallback :: Maybe SourceCallbackFuncsRefFieldCallback Source #

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

noSourceCallbackFuncsRefFieldCallback_WithClosures :: Maybe SourceCallbackFuncsRefFieldCallback_WithClosures Source #

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

wrap_SourceCallbackFuncsRefFieldCallback :: Maybe (Ptr (FunPtr C_SourceCallbackFuncsRefFieldCallback)) -> SourceCallbackFuncsRefFieldCallback_WithClosures -> C_SourceCallbackFuncsRefFieldCallback Source #

Wrap a `SourceCallbackFuncsRefFieldCallback` into a `C_SourceCallbackFuncsRefFieldCallback`.

## SourceCallbackFuncsUnrefFieldCallback

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

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

type SourceCallbackFuncsUnrefFieldCallback = IO () Source #

No description available in the introspection data.

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

No description available in the introspection data.

drop_closures_SourceCallbackFuncsUnrefFieldCallback :: SourceCallbackFuncsUnrefFieldCallback -> SourceCallbackFuncsUnrefFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SourceCallbackFuncsUnrefFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceCallbackFuncsUnrefFieldCallback -> Ptr () -> m () Source #

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

genClosure_SourceCallbackFuncsUnrefFieldCallback :: MonadIO m => SourceCallbackFuncsUnrefFieldCallback -> m (GClosure C_SourceCallbackFuncsUnrefFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_SourceCallbackFuncsUnrefFieldCallback :: C_SourceCallbackFuncsUnrefFieldCallback -> IO (FunPtr C_SourceCallbackFuncsUnrefFieldCallback) Source #

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

noSourceCallbackFuncsUnrefFieldCallback :: Maybe SourceCallbackFuncsUnrefFieldCallback Source #

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

noSourceCallbackFuncsUnrefFieldCallback_WithClosures :: Maybe SourceCallbackFuncsUnrefFieldCallback_WithClosures Source #

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

wrap_SourceCallbackFuncsUnrefFieldCallback :: Maybe (Ptr (FunPtr C_SourceCallbackFuncsUnrefFieldCallback)) -> SourceCallbackFuncsUnrefFieldCallback_WithClosures -> C_SourceCallbackFuncsUnrefFieldCallback Source #

Wrap a `SourceCallbackFuncsUnrefFieldCallback` into a `C_SourceCallbackFuncsUnrefFieldCallback`.

## SourceDisposeFunc

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

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

type SourceDisposeFunc Source #

Arguments

= Source | `source`: `Source` that is currently being disposed
-> IO () |

Dispose function for `source`. See `g_source_set_dispose_function()` for details.

Since: 2.64

dynamic_SourceDisposeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_SourceDisposeFunc |
-> Source | `source`: `Source` that is currently being disposed
-> m () |

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

genClosure_SourceDisposeFunc :: MonadIO m => SourceDisposeFunc -> m (GClosure C_SourceDisposeFunc) Source #

Wrap the callback into a `GClosure`.

mk_SourceDisposeFunc :: C_SourceDisposeFunc -> IO (FunPtr C_SourceDisposeFunc) Source #

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

noSourceDisposeFunc :: Maybe SourceDisposeFunc Source #

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

wrap_SourceDisposeFunc :: Maybe (Ptr (FunPtr C_SourceDisposeFunc)) -> SourceDisposeFunc -> C_SourceDisposeFunc Source #

Wrap a `SourceDisposeFunc` into a `C_SourceDisposeFunc`.

## SourceDummyMarshal

type C_SourceDummyMarshal = IO () Source #

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

type SourceDummyMarshal = IO () Source #

This is just a placeholder for `GClosureMarshal`, which cannot be used here for dependency reasons.

dynamic_SourceDummyMarshal :: (HasCallStack, MonadIO m) => FunPtr C_SourceDummyMarshal -> m () Source #

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

genClosure_SourceDummyMarshal :: MonadIO m => SourceDummyMarshal -> m (GClosure C_SourceDummyMarshal) Source #

Wrap the callback into a `GClosure`.

mk_SourceDummyMarshal :: C_SourceDummyMarshal -> IO (FunPtr C_SourceDummyMarshal) Source #

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

noSourceDummyMarshal :: Maybe SourceDummyMarshal Source #

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

wrap_SourceDummyMarshal :: Maybe (Ptr (FunPtr C_SourceDummyMarshal)) -> SourceDummyMarshal -> C_SourceDummyMarshal Source #

Wrap a `SourceDummyMarshal` into a `C_SourceDummyMarshal`.

## SourceFunc

type C_SourceFunc = Ptr () -> IO CInt Source #

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

type SourceFunc Source #

Arguments

= IO Bool | Returns: `False` if the source should be removed. `SOURCE_CONTINUE` and `SOURCE_REMOVE` are more memorable names for the return value.

Specifies the type of function passed to `g_timeout_add()`, `timeoutAdd`, `g_idle_add()`, and `idleAdd`.

When calling `sourceSetCallback`, you may need to cast a function of a different type to this type. Use `G_SOURCE_FUNC()` to avoid warnings about incompatible function types.

type SourceFunc_WithClosures Source #

Arguments

= Ptr () | `userData`: data passed to the function, set when the source was created with one of the above functions
-> IO Bool | Returns: `False` if the source should be removed. `SOURCE_CONTINUE` and `SOURCE_REMOVE` are more memorable names for the return value.

Specifies the type of function passed to `g_timeout_add()`, `timeoutAdd`, `g_idle_add()`, and `idleAdd`.

When calling `sourceSetCallback`, you may need to cast a function of a different type to this type. Use `G_SOURCE_FUNC()` to avoid warnings about incompatible function types.

drop_closures_SourceFunc :: SourceFunc -> SourceFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SourceFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_SourceFunc |
-> Ptr () | `userData`: data passed to the function, set when the source was created with one of the above functions
-> m Bool | Returns: `False` if the source should be removed. `SOURCE_CONTINUE` and `SOURCE_REMOVE` are more memorable names for the return value.

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

genClosure_SourceFunc :: MonadIO m => SourceFunc -> m (GClosure C_SourceFunc) Source #

Wrap the callback into a `GClosure`.

mk_SourceFunc :: C_SourceFunc -> IO (FunPtr C_SourceFunc) Source #

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

noSourceFunc :: Maybe SourceFunc Source #

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

noSourceFunc_WithClosures :: Maybe SourceFunc_WithClosures Source #

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

wrap_SourceFunc :: Maybe (Ptr (FunPtr C_SourceFunc)) -> SourceFunc_WithClosures -> C_SourceFunc Source #

Wrap a `SourceFunc` into a `C_SourceFunc`.

## SourceFuncsCheckFieldCallback

type C_SourceFuncsCheckFieldCallback = Ptr Source -> IO CInt Source #

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

type SourceFuncsCheckFieldCallback = Source -> IO Bool Source #

No description available in the introspection data.

dynamic_SourceFuncsCheckFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsCheckFieldCallback -> Source -> m Bool Source #

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

genClosure_SourceFuncsCheckFieldCallback :: MonadIO m => SourceFuncsCheckFieldCallback -> m (GClosure C_SourceFuncsCheckFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_SourceFuncsCheckFieldCallback :: C_SourceFuncsCheckFieldCallback -> IO (FunPtr C_SourceFuncsCheckFieldCallback) Source #

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

noSourceFuncsCheckFieldCallback :: Maybe SourceFuncsCheckFieldCallback Source #

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

wrap_SourceFuncsCheckFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsCheckFieldCallback)) -> SourceFuncsCheckFieldCallback -> C_SourceFuncsCheckFieldCallback Source #

Wrap a `SourceFuncsCheckFieldCallback` into a `C_SourceFuncsCheckFieldCallback`.

## SourceFuncsFinalizeFieldCallback

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

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

type SourceFuncsFinalizeFieldCallback = Source -> IO () Source #

No description available in the introspection data.

dynamic_SourceFuncsFinalizeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsFinalizeFieldCallback -> Source -> m () Source #

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

genClosure_SourceFuncsFinalizeFieldCallback :: MonadIO m => SourceFuncsFinalizeFieldCallback -> m (GClosure C_SourceFuncsFinalizeFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_SourceFuncsFinalizeFieldCallback :: C_SourceFuncsFinalizeFieldCallback -> IO (FunPtr C_SourceFuncsFinalizeFieldCallback) Source #

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

noSourceFuncsFinalizeFieldCallback :: Maybe SourceFuncsFinalizeFieldCallback Source #

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

wrap_SourceFuncsFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsFinalizeFieldCallback)) -> SourceFuncsFinalizeFieldCallback -> C_SourceFuncsFinalizeFieldCallback Source #

Wrap a `SourceFuncsFinalizeFieldCallback` into a `C_SourceFuncsFinalizeFieldCallback`.

## SourceFuncsPrepareFieldCallback

type C_SourceFuncsPrepareFieldCallback = Ptr Source -> Int32 -> IO CInt Source #

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

type SourceFuncsPrepareFieldCallback = Source -> Int32 -> IO Bool Source #

No description available in the introspection data.

dynamic_SourceFuncsPrepareFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsPrepareFieldCallback -> Source -> Int32 -> m Bool Source #

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

genClosure_SourceFuncsPrepareFieldCallback :: MonadIO m => SourceFuncsPrepareFieldCallback -> m (GClosure C_SourceFuncsPrepareFieldCallback) Source #

Wrap the callback into a `GClosure`.

mk_SourceFuncsPrepareFieldCallback :: C_SourceFuncsPrepareFieldCallback -> IO (FunPtr C_SourceFuncsPrepareFieldCallback) Source #

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

noSourceFuncsPrepareFieldCallback :: Maybe SourceFuncsPrepareFieldCallback Source #

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

wrap_SourceFuncsPrepareFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsPrepareFieldCallback)) -> SourceFuncsPrepareFieldCallback -> C_SourceFuncsPrepareFieldCallback Source #

Wrap a `SourceFuncsPrepareFieldCallback` into a `C_SourceFuncsPrepareFieldCallback`.

## SourceOnceFunc

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

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

type SourceOnceFunc = IO () Source #

A source function that is only called once before being removed from the main context automatically.

See: `g_idle_add_once()`, `g_timeout_add_once()`

Since: 2.74

type SourceOnceFunc_WithClosures Source #

Arguments

= Ptr () | `userData`: data passed to the function, set when the source was created
-> IO () |

A source function that is only called once before being removed from the main context automatically.

See: `g_idle_add_once()`, `g_timeout_add_once()`

Since: 2.74

drop_closures_SourceOnceFunc :: SourceOnceFunc -> SourceOnceFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SourceOnceFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_SourceOnceFunc |
-> Ptr () | `userData`: data passed to the function, set when the source was created
-> m () |

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

genClosure_SourceOnceFunc :: MonadIO m => SourceOnceFunc -> m (GClosure C_SourceOnceFunc) Source #

Wrap the callback into a `GClosure`.

mk_SourceOnceFunc :: C_SourceOnceFunc -> IO (FunPtr C_SourceOnceFunc) Source #

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

noSourceOnceFunc :: Maybe SourceOnceFunc Source #

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

noSourceOnceFunc_WithClosures :: Maybe SourceOnceFunc_WithClosures Source #

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

wrap_SourceOnceFunc :: Maybe (Ptr (FunPtr C_SourceOnceFunc)) -> SourceOnceFunc_WithClosures -> C_SourceOnceFunc Source #

Wrap a `SourceOnceFunc` into a `C_SourceOnceFunc`.

## SpawnChildSetupFunc

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

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

type SpawnChildSetupFunc = IO () Source #

Specifies the type of the setup function passed to `spawnAsync`, `spawnSync` and `spawnAsyncWithPipes`, which can, in very limited ways, be used to affect the child's execution.

On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform, but before calling `exec()`. Actions taken in this function will only affect the child, not the parent.

On Windows, the function is called in the parent. Its usefulness on Windows is thus questionable. In many cases executing the child setup function in the parent can have ill effects, and you should be very careful when porting software to Windows that uses child setup functions.

However, even on POSIX, you are extremely limited in what you can safely do from a `SpawnChildSetupFunc`, because any mutexes that were held by other threads in the parent process at the time of the `fork()` will still be locked in the child process, and they will never be unlocked (since the threads that held them don't exist in the child). POSIX allows only async-signal-safe functions (see signal(7)) to be called in the child between `fork()` and `exec()`, which drastically limits the usefulness of child setup functions.

In particular, it is not safe to call any function which may call `malloc()`, which includes POSIX functions such as `setenv()`. If you need to set up the child environment differently from the parent, you should use `getEnviron`, `environSetenv`, and `environUnsetenv`, and then pass the complete environment list to the `g_spawn...` function.

type SpawnChildSetupFunc_WithClosures Source #

Arguments

= Ptr () | `data`: user data passed to the function.
-> IO () |

Specifies the type of the setup function passed to `spawnAsync`, `spawnSync` and `spawnAsyncWithPipes`, which can, in very limited ways, be used to affect the child's execution.

On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform, but before calling `exec()`. Actions taken in this function will only affect the child, not the parent.

On Windows, the function is called in the parent. Its usefulness on Windows is thus questionable. In many cases executing the child setup function in the parent can have ill effects, and you should be very careful when porting software to Windows that uses child setup functions.

However, even on POSIX, you are extremely limited in what you can safely do from a `SpawnChildSetupFunc`, because any mutexes that were held by other threads in the parent process at the time of the `fork()` will still be locked in the child process, and they will never be unlocked (since the threads that held them don't exist in the child). POSIX allows only async-signal-safe functions (see signal(7)) to be called in the child between `fork()` and `exec()`, which drastically limits the usefulness of child setup functions.

In particular, it is not safe to call any function which may call `malloc()`, which includes POSIX functions such as `setenv()`. If you need to set up the child environment differently from the parent, you should use `getEnviron`, `environSetenv`, and `environUnsetenv`, and then pass the complete environment list to the `g_spawn...` function.

drop_closures_SpawnChildSetupFunc :: SpawnChildSetupFunc -> SpawnChildSetupFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SpawnChildSetupFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_SpawnChildSetupFunc |
-> Ptr () | `data`: user data passed to the function.
-> m () |

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

genClosure_SpawnChildSetupFunc :: MonadIO m => SpawnChildSetupFunc -> m (GClosure C_SpawnChildSetupFunc) Source #

Wrap the callback into a `GClosure`.

mk_SpawnChildSetupFunc :: C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc) Source #

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

noSpawnChildSetupFunc :: Maybe SpawnChildSetupFunc Source #

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

noSpawnChildSetupFunc_WithClosures :: Maybe SpawnChildSetupFunc_WithClosures Source #

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

wrap_SpawnChildSetupFunc :: Maybe (Ptr (FunPtr C_SpawnChildSetupFunc)) -> SpawnChildSetupFunc_WithClosures -> C_SpawnChildSetupFunc Source #

Wrap a `SpawnChildSetupFunc` into a `C_SpawnChildSetupFunc`.

## TestDataFunc

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

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

type TestDataFunc = IO () Source #

The type used for test case functions that take an extra pointer argument.

Since: 2.28

type TestDataFunc_WithClosures Source #

Arguments

= Ptr () | `userData`: the data provided when registering the test
-> IO () |

The type used for test case functions that take an extra pointer argument.

Since: 2.28

drop_closures_TestDataFunc :: TestDataFunc -> TestDataFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TestDataFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TestDataFunc |
-> Ptr () | `userData`: the data provided when registering the test
-> m () |

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

genClosure_TestDataFunc :: MonadIO m => TestDataFunc -> m (GClosure C_TestDataFunc) Source #

Wrap the callback into a `GClosure`.

mk_TestDataFunc :: C_TestDataFunc -> IO (FunPtr C_TestDataFunc) Source #

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

noTestDataFunc :: Maybe TestDataFunc Source #

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

noTestDataFunc_WithClosures :: Maybe TestDataFunc_WithClosures Source #

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

wrap_TestDataFunc :: Maybe (Ptr (FunPtr C_TestDataFunc)) -> TestDataFunc_WithClosures -> C_TestDataFunc Source #

Wrap a `TestDataFunc` into a `C_TestDataFunc`.

## TestFixtureFunc

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

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

type TestFixtureFunc Source #

Arguments

= Ptr () | `fixture`: the test fixture
-> IO () |

The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves.

`userData` is a pointer to the data that was given when registering the test case.

`fixture` will be a pointer to the area of memory allocated by the test framework, of the size requested. If the requested size was zero then `fixture` will be equal to `userData`.

Since: 2.28

type TestFixtureFunc_WithClosures Source #

Arguments

= Ptr () | `fixture`: the test fixture
-> Ptr () | `userData`: the data provided when registering the test
-> IO () |

The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves.

`userData` is a pointer to the data that was given when registering the test case.

`fixture` will be a pointer to the area of memory allocated by the test framework, of the size requested. If the requested size was zero then `fixture` will be equal to `userData`.

Since: 2.28

drop_closures_TestFixtureFunc :: TestFixtureFunc -> TestFixtureFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TestFixtureFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TestFixtureFunc |
-> Ptr () | `fixture`: the test fixture
-> Ptr () | `userData`: the data provided when registering the test
-> m () |

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

genClosure_TestFixtureFunc :: MonadIO m => TestFixtureFunc -> m (GClosure C_TestFixtureFunc) Source #

Wrap the callback into a `GClosure`.

mk_TestFixtureFunc :: C_TestFixtureFunc -> IO (FunPtr C_TestFixtureFunc) Source #

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

noTestFixtureFunc :: Maybe TestFixtureFunc Source #

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

noTestFixtureFunc_WithClosures :: Maybe TestFixtureFunc_WithClosures Source #

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

wrap_TestFixtureFunc :: Maybe (Ptr (FunPtr C_TestFixtureFunc)) -> TestFixtureFunc_WithClosures -> C_TestFixtureFunc Source #

Wrap a `TestFixtureFunc` into a `C_TestFixtureFunc`.

## TestFunc

type C_TestFunc = IO () Source #

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

type TestFunc = IO () Source #

The type used for test case functions.

Since: 2.28

dynamic_TestFunc :: (HasCallStack, MonadIO m) => FunPtr C_TestFunc -> m () Source #

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

genClosure_TestFunc :: MonadIO m => TestFunc -> m (GClosure C_TestFunc) Source #

Wrap the callback into a `GClosure`.

mk_TestFunc :: C_TestFunc -> IO (FunPtr C_TestFunc) Source #

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

noTestFunc :: Maybe TestFunc Source #

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

wrap_TestFunc :: Maybe (Ptr (FunPtr C_TestFunc)) -> TestFunc -> C_TestFunc Source #

Wrap a `TestFunc` into a `C_TestFunc`.

## TestLogFatalFunc

type C_TestLogFatalFunc = CString -> CInt -> CString -> Ptr () -> IO CInt Source #

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

type TestLogFatalFunc Source #

Arguments

= Text | `logDomain`: the log domain of the message
-> [LogLevelFlags] | `logLevel`: the log level of the message (including the fatal and recursion flags)
-> Text | `message`: the message to process
-> IO Bool | Returns: `True` if the program should abort, `False` otherwise

Specifies the prototype of fatal log handler functions.

Since: 2.22

type TestLogFatalFunc_WithClosures Source #

Arguments

= Text | `logDomain`: the log domain of the message
-> [LogLevelFlags] | `logLevel`: the log level of the message (including the fatal and recursion flags)
-> Text | `message`: the message to process
-> Ptr () | `userData`: user data, set in `g_test_log_set_fatal_handler()`
-> IO Bool | Returns: `True` if the program should abort, `False` otherwise

Specifies the prototype of fatal log handler functions.

Since: 2.22

drop_closures_TestLogFatalFunc :: TestLogFatalFunc -> TestLogFatalFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TestLogFatalFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TestLogFatalFunc |
-> Text | `logDomain`: the log domain of the message
-> [LogLevelFlags] | `logLevel`: the log level of the message (including the fatal and recursion flags)
-> Text | `message`: the message to process
-> Ptr () | `userData`: user data, set in `g_test_log_set_fatal_handler()`
-> m Bool | Returns: `True` if the program should abort, `False` otherwise

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

genClosure_TestLogFatalFunc :: MonadIO m => TestLogFatalFunc -> m (GClosure C_TestLogFatalFunc) Source #

Wrap the callback into a `GClosure`.

mk_TestLogFatalFunc :: C_TestLogFatalFunc -> IO (FunPtr C_TestLogFatalFunc) Source #

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

noTestLogFatalFunc :: Maybe TestLogFatalFunc Source #

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

noTestLogFatalFunc_WithClosures :: Maybe TestLogFatalFunc_WithClosures Source #

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

wrap_TestLogFatalFunc :: Maybe (Ptr (FunPtr C_TestLogFatalFunc)) -> TestLogFatalFunc_WithClosures -> C_TestLogFatalFunc Source #

Wrap a `TestLogFatalFunc` into a `C_TestLogFatalFunc`.

## ThreadFunc

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

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

type ThreadFunc Source #

Arguments

= IO (Ptr ()) | Returns: the return value of the thread

Specifies the type of the `func` functions passed to `threadNew` or `threadTryNew`.

type ThreadFunc_WithClosures Source #

Arguments

= Ptr () | `data`: data passed to the thread
-> IO (Ptr ()) | Returns: the return value of the thread

Specifies the type of the `func` functions passed to `threadNew` or `threadTryNew`.

drop_closures_ThreadFunc :: ThreadFunc -> ThreadFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ThreadFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_ThreadFunc |
-> Ptr () | `data`: data passed to the thread
-> m (Ptr ()) | Returns: the return value of the thread

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

genClosure_ThreadFunc :: MonadIO m => ThreadFunc -> m (GClosure C_ThreadFunc) Source #

Wrap the callback into a `GClosure`.

mk_ThreadFunc :: C_ThreadFunc -> IO (FunPtr C_ThreadFunc) Source #

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

noThreadFunc :: Maybe ThreadFunc Source #

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

noThreadFunc_WithClosures :: Maybe ThreadFunc_WithClosures Source #

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

wrap_ThreadFunc :: Maybe (Ptr (FunPtr C_ThreadFunc)) -> ThreadFunc_WithClosures -> C_ThreadFunc Source #

Wrap a `ThreadFunc` into a `C_ThreadFunc`.

## TranslateFunc

type C_TranslateFunc = CString -> Ptr () -> IO CString Source #

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

type TranslateFunc Source #

Arguments

= Text | `str`: the untranslated string
-> IO Text | Returns: a translation of the string for the current locale. The returned string is owned by GLib and must not be freed.

The type of functions which are used to translate user-visible strings, for <option>--help</option> output.

type TranslateFunc_WithClosures Source #

Arguments

= Text | `str`: the untranslated string
-> Ptr () | `data`: user data specified when installing the function, e.g. in `optionGroupSetTranslateFunc`
-> IO Text | Returns: a translation of the string for the current locale. The returned string is owned by GLib and must not be freed.

The type of functions which are used to translate user-visible strings, for <option>--help</option> output.

drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TranslateFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TranslateFunc |
-> Text | `str`: the untranslated string
-> Ptr () | `data`: user data specified when installing the function, e.g. in `optionGroupSetTranslateFunc`
-> m Text | Returns: a translation of the string for the current locale. The returned string is owned by GLib and must not be freed.

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

genClosure_TranslateFunc :: MonadIO m => TranslateFunc -> m (GClosure C_TranslateFunc) Source #

Wrap the callback into a `GClosure`.

mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc) Source #

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

noTranslateFunc :: Maybe TranslateFunc Source #

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

noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures Source #

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

wrap_TranslateFunc :: Maybe (Ptr (FunPtr C_TranslateFunc)) -> TranslateFunc_WithClosures -> C_TranslateFunc Source #

Wrap a `TranslateFunc` into a `C_TranslateFunc`.

## TraverseFunc

type C_TraverseFunc = Ptr () -> Ptr () -> Ptr () -> IO CInt Source #

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

type TraverseFunc Source #

Arguments

= Ptr () | `key`: a key of a `Tree` node
-> Ptr () | `value`: the value corresponding to the key
-> IO Bool | Returns: `True` to stop the traversal

Specifies the type of function passed to `treeTraverse`. It is passed the key and value of each node, together with the `userData` parameter passed to `treeTraverse`. If the function returns `True`, the traversal is stopped.

type TraverseFunc_WithClosures Source #

Arguments

= Ptr () | `key`: a key of a `Tree` node
-> Ptr () | `value`: the value corresponding to the key
-> Ptr () | `data`: user data passed to `treeTraverse`
-> IO Bool | Returns: `True` to stop the traversal

Specifies the type of function passed to `treeTraverse`. It is passed the key and value of each node, together with the `userData` parameter passed to `treeTraverse`. If the function returns `True`, the traversal is stopped.

drop_closures_TraverseFunc :: TraverseFunc -> TraverseFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TraverseFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TraverseFunc |
-> Ptr () | `key`: a key of a `Tree` node
-> Ptr () | `value`: the value corresponding to the key
-> Ptr () | `data`: user data passed to `treeTraverse`
-> m Bool | Returns: `True` to stop the traversal

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

genClosure_TraverseFunc :: MonadIO m => TraverseFunc -> m (GClosure C_TraverseFunc) Source #

Wrap the callback into a `GClosure`.

mk_TraverseFunc :: C_TraverseFunc -> IO (FunPtr C_TraverseFunc) Source #

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

noTraverseFunc :: Maybe TraverseFunc Source #

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

noTraverseFunc_WithClosures :: Maybe TraverseFunc_WithClosures Source #

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

wrap_TraverseFunc :: Maybe (Ptr (FunPtr C_TraverseFunc)) -> TraverseFunc_WithClosures -> C_TraverseFunc Source #

Wrap a `TraverseFunc` into a `C_TraverseFunc`.

## TraverseNodeFunc

type C_TraverseNodeFunc = Ptr TreeNode -> Ptr () -> IO CInt Source #

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

type TraverseNodeFunc Source #

Arguments

= TreeNode | `node`: a `TreeNode`
-> IO Bool | Returns: `True` to stop the traversal

Specifies the type of function passed to `treeForeachNode`. It is passed each node, together with the `userData` parameter passed to `treeForeachNode`. If the function returns `True`, the traversal is stopped.

Since: 2.68

type TraverseNodeFunc_WithClosures Source #

Arguments

= TreeNode | `node`: a `TreeNode`
-> Ptr () | `data`: user data passed to `treeForeachNode`
-> IO Bool | Returns: `True` to stop the traversal

Specifies the type of function passed to `treeForeachNode`. It is passed each node, together with the `userData` parameter passed to `treeForeachNode`. If the function returns `True`, the traversal is stopped.

Since: 2.68

drop_closures_TraverseNodeFunc :: TraverseNodeFunc -> TraverseNodeFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_TraverseNodeFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_TraverseNodeFunc |
-> TreeNode | `node`: a `TreeNode`
-> Ptr () | `data`: user data passed to `treeForeachNode`
-> m Bool | Returns: `True` to stop the traversal

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

genClosure_TraverseNodeFunc :: MonadIO m => TraverseNodeFunc -> m (GClosure C_TraverseNodeFunc) Source #

Wrap the callback into a `GClosure`.

mk_TraverseNodeFunc :: C_TraverseNodeFunc -> IO (FunPtr C_TraverseNodeFunc) Source #

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

noTraverseNodeFunc :: Maybe TraverseNodeFunc Source #

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

noTraverseNodeFunc_WithClosures :: Maybe TraverseNodeFunc_WithClosures Source #

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

wrap_TraverseNodeFunc :: Maybe (Ptr (FunPtr C_TraverseNodeFunc)) -> TraverseNodeFunc_WithClosures -> C_TraverseNodeFunc Source #

Wrap a `TraverseNodeFunc` into a `C_TraverseNodeFunc`.

## UnixFDSourceFunc

type C_UnixFDSourceFunc = Int32 -> CUInt -> Ptr () -> IO CInt Source #

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

type UnixFDSourceFunc Source #

Arguments

= Int32 | `fd`: the fd that triggered the event
-> [IOCondition] | `condition`: the IO conditions reported on `fd`
-> IO Bool | Returns: `False` if the source should be removed

The type of functions to be called when a UNIX fd watch source triggers.

type UnixFDSourceFunc_WithClosures Source #

Arguments

= Int32 | `fd`: the fd that triggered the event
-> [IOCondition] | `condition`: the IO conditions reported on `fd`
-> Ptr () | `userData`: user data passed to `g_unix_fd_add()`
-> IO Bool | Returns: `False` if the source should be removed

The type of functions to be called when a UNIX fd watch source triggers.

drop_closures_UnixFDSourceFunc :: UnixFDSourceFunc -> UnixFDSourceFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_UnixFDSourceFunc Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> FunPtr C_UnixFDSourceFunc |
-> Int32 | `fd`: the fd that triggered the event
-> [IOCondition] | `condition`: the IO conditions reported on `fd`
-> Ptr () | `userData`: user data passed to `g_unix_fd_add()`
-> m Bool | Returns: `False` if the source should be removed

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

genClosure_UnixFDSourceFunc :: MonadIO m => UnixFDSourceFunc -> m (GClosure C_UnixFDSourceFunc) Source #

Wrap the callback into a `GClosure`.

mk_UnixFDSourceFunc :: C_UnixFDSourceFunc -> IO (FunPtr C_UnixFDSourceFunc) Source #

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

noUnixFDSourceFunc :: Maybe UnixFDSourceFunc Source #

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

noUnixFDSourceFunc_WithClosures :: Maybe UnixFDSourceFunc_WithClosures Source #

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

wrap_UnixFDSourceFunc :: Maybe (Ptr (FunPtr C_UnixFDSourceFunc)) -> UnixFDSourceFunc_WithClosures -> C_UnixFDSourceFunc Source #

Wrap a `UnixFDSourceFunc` into a `C_UnixFDSourceFunc`.

## VoidFunc

type C_VoidFunc = IO () Source #

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

type VoidFunc = IO () Source #

Declares a type of function which takes no arguments and has no return value. It is used to specify the type function passed to `atexit`.

dynamic_VoidFunc :: (HasCallStack, MonadIO m) => FunPtr C_VoidFunc -> m () Source #

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

genClosure_VoidFunc :: MonadIO m => VoidFunc -> m (GClosure C_VoidFunc) Source #

Wrap the callback into a `GClosure`.

mk_VoidFunc :: C_VoidFunc -> IO (FunPtr C_VoidFunc) Source #

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

noVoidFunc :: Maybe VoidFunc Source #

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

wrap_VoidFunc :: Maybe (Ptr (FunPtr C_VoidFunc)) -> VoidFunc -> C_VoidFunc Source #

Wrap a `VoidFunc` into a `C_VoidFunc`.