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.Gio.Callbacks

Contents

Signals

Description

Synopsis

type ActionEntryActivateFieldCallback = SimpleAction -> Maybe GVariant -> IO ()
type ActionEntryActivateFieldCallback_WithClosures = SimpleAction -> Maybe GVariant -> Ptr () -> IO ()
type C_ActionEntryActivateFieldCallback = Ptr SimpleAction -> Ptr GVariant -> Ptr () -> IO ()
drop_closures_ActionEntryActivateFieldCallback :: ActionEntryActivateFieldCallback -> ActionEntryActivateFieldCallback_WithClosures
dynamic_ActionEntryActivateFieldCallback :: (HasCallStack, MonadIO m, IsSimpleAction a) => FunPtr C_ActionEntryActivateFieldCallback -> a -> Maybe GVariant -> Ptr () -> m ()
genClosure_ActionEntryActivateFieldCallback :: MonadIO m => ActionEntryActivateFieldCallback -> m (GClosure C_ActionEntryActivateFieldCallback)
mk_ActionEntryActivateFieldCallback :: C_ActionEntryActivateFieldCallback -> IO (FunPtr C_ActionEntryActivateFieldCallback)
noActionEntryActivateFieldCallback :: Maybe ActionEntryActivateFieldCallback
noActionEntryActivateFieldCallback_WithClosures :: Maybe ActionEntryActivateFieldCallback_WithClosures
wrap_ActionEntryActivateFieldCallback :: Maybe (Ptr (FunPtr C_ActionEntryActivateFieldCallback)) -> ActionEntryActivateFieldCallback_WithClosures -> C_ActionEntryActivateFieldCallback
type ActionEntryChangeStateFieldCallback = SimpleAction -> GVariant -> IO ()
type ActionEntryChangeStateFieldCallback_WithClosures = SimpleAction -> GVariant -> Ptr () -> IO ()
type C_ActionEntryChangeStateFieldCallback = Ptr SimpleAction -> Ptr GVariant -> Ptr () -> IO ()
drop_closures_ActionEntryChangeStateFieldCallback :: ActionEntryChangeStateFieldCallback -> ActionEntryChangeStateFieldCallback_WithClosures
dynamic_ActionEntryChangeStateFieldCallback :: (HasCallStack, MonadIO m, IsSimpleAction a) => FunPtr C_ActionEntryChangeStateFieldCallback -> a -> GVariant -> Ptr () -> m ()
genClosure_ActionEntryChangeStateFieldCallback :: MonadIO m => ActionEntryChangeStateFieldCallback -> m (GClosure C_ActionEntryChangeStateFieldCallback)
mk_ActionEntryChangeStateFieldCallback :: C_ActionEntryChangeStateFieldCallback -> IO (FunPtr C_ActionEntryChangeStateFieldCallback)
noActionEntryChangeStateFieldCallback :: Maybe ActionEntryChangeStateFieldCallback
noActionEntryChangeStateFieldCallback_WithClosures :: Maybe ActionEntryChangeStateFieldCallback_WithClosures
wrap_ActionEntryChangeStateFieldCallback :: Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback)) -> ActionEntryChangeStateFieldCallback_WithClosures -> C_ActionEntryChangeStateFieldCallback
type AsyncReadyCallback = Maybe Object -> AsyncResult -> IO ()
type AsyncReadyCallback_WithClosures = Maybe Object -> AsyncResult -> Ptr () -> IO ()
type C_AsyncReadyCallback = Ptr Object -> Ptr AsyncResult -> Ptr () -> IO ()
drop_closures_AsyncReadyCallback :: AsyncReadyCallback -> AsyncReadyCallback_WithClosures
dynamic_AsyncReadyCallback :: (HasCallStack, MonadIO m, IsObject a, IsAsyncResult b) => FunPtr C_AsyncReadyCallback -> Maybe a -> b -> Ptr () -> m ()
genClosure_AsyncReadyCallback :: MonadIO m => AsyncReadyCallback -> m (GClosure C_AsyncReadyCallback)
mk_AsyncReadyCallback :: C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
noAsyncReadyCallback :: Maybe AsyncReadyCallback
noAsyncReadyCallback_WithClosures :: Maybe AsyncReadyCallback_WithClosures
wrap_AsyncReadyCallback :: Maybe (Ptr (FunPtr C_AsyncReadyCallback)) -> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
type BusAcquiredCallback = DBusConnection -> Text -> IO ()
type BusAcquiredCallback_WithClosures = DBusConnection -> Text -> Ptr () -> IO ()
type C_BusAcquiredCallback = Ptr DBusConnection -> CString -> Ptr () -> IO ()
drop_closures_BusAcquiredCallback :: BusAcquiredCallback -> BusAcquiredCallback_WithClosures
dynamic_BusAcquiredCallback :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_BusAcquiredCallback -> a -> Text -> Ptr () -> m ()
genClosure_BusAcquiredCallback :: MonadIO m => BusAcquiredCallback -> m (GClosure C_BusAcquiredCallback)
mk_BusAcquiredCallback :: C_BusAcquiredCallback -> IO (FunPtr C_BusAcquiredCallback)
noBusAcquiredCallback :: Maybe BusAcquiredCallback
noBusAcquiredCallback_WithClosures :: Maybe BusAcquiredCallback_WithClosures
wrap_BusAcquiredCallback :: Maybe (Ptr (FunPtr C_BusAcquiredCallback)) -> BusAcquiredCallback_WithClosures -> C_BusAcquiredCallback
type BusNameAcquiredCallback = DBusConnection -> Text -> IO ()
type BusNameAcquiredCallback_WithClosures = DBusConnection -> Text -> Ptr () -> IO ()
type C_BusNameAcquiredCallback = Ptr DBusConnection -> CString -> Ptr () -> IO ()
drop_closures_BusNameAcquiredCallback :: BusNameAcquiredCallback -> BusNameAcquiredCallback_WithClosures
dynamic_BusNameAcquiredCallback :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_BusNameAcquiredCallback -> a -> Text -> Ptr () -> m ()
genClosure_BusNameAcquiredCallback :: MonadIO m => BusNameAcquiredCallback -> m (GClosure C_BusNameAcquiredCallback)
mk_BusNameAcquiredCallback :: C_BusNameAcquiredCallback -> IO (FunPtr C_BusNameAcquiredCallback)
noBusNameAcquiredCallback :: Maybe BusNameAcquiredCallback
noBusNameAcquiredCallback_WithClosures :: Maybe BusNameAcquiredCallback_WithClosures
wrap_BusNameAcquiredCallback :: Maybe (Ptr (FunPtr C_BusNameAcquiredCallback)) -> BusNameAcquiredCallback_WithClosures -> C_BusNameAcquiredCallback
type BusNameAppearedCallback = DBusConnection -> Text -> Text -> IO ()
type BusNameAppearedCallback_WithClosures = DBusConnection -> Text -> Text -> Ptr () -> IO ()
type C_BusNameAppearedCallback = Ptr DBusConnection -> CString -> CString -> Ptr () -> IO ()
drop_closures_BusNameAppearedCallback :: BusNameAppearedCallback -> BusNameAppearedCallback_WithClosures
dynamic_BusNameAppearedCallback :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_BusNameAppearedCallback -> a -> Text -> Text -> Ptr () -> m ()
genClosure_BusNameAppearedCallback :: MonadIO m => BusNameAppearedCallback -> m (GClosure C_BusNameAppearedCallback)
mk_BusNameAppearedCallback :: C_BusNameAppearedCallback -> IO (FunPtr C_BusNameAppearedCallback)
noBusNameAppearedCallback :: Maybe BusNameAppearedCallback
noBusNameAppearedCallback_WithClosures :: Maybe BusNameAppearedCallback_WithClosures
wrap_BusNameAppearedCallback :: Maybe (Ptr (FunPtr C_BusNameAppearedCallback)) -> BusNameAppearedCallback_WithClosures -> C_BusNameAppearedCallback
type BusNameLostCallback = DBusConnection -> Text -> IO ()
type BusNameLostCallback_WithClosures = DBusConnection -> Text -> Ptr () -> IO ()
type C_BusNameLostCallback = Ptr DBusConnection -> CString -> Ptr () -> IO ()
drop_closures_BusNameLostCallback :: BusNameLostCallback -> BusNameLostCallback_WithClosures
dynamic_BusNameLostCallback :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_BusNameLostCallback -> a -> Text -> Ptr () -> m ()
genClosure_BusNameLostCallback :: MonadIO m => BusNameLostCallback -> m (GClosure C_BusNameLostCallback)
mk_BusNameLostCallback :: C_BusNameLostCallback -> IO (FunPtr C_BusNameLostCallback)
noBusNameLostCallback :: Maybe BusNameLostCallback
noBusNameLostCallback_WithClosures :: Maybe BusNameLostCallback_WithClosures
wrap_BusNameLostCallback :: Maybe (Ptr (FunPtr C_BusNameLostCallback)) -> BusNameLostCallback_WithClosures -> C_BusNameLostCallback
type BusNameVanishedCallback = DBusConnection -> Text -> IO ()
type BusNameVanishedCallback_WithClosures = DBusConnection -> Text -> Ptr () -> IO ()
type C_BusNameVanishedCallback = Ptr DBusConnection -> CString -> Ptr () -> IO ()
drop_closures_BusNameVanishedCallback :: BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures
dynamic_BusNameVanishedCallback :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_BusNameVanishedCallback -> a -> Text -> Ptr () -> m ()
genClosure_BusNameVanishedCallback :: MonadIO m => BusNameVanishedCallback -> m (GClosure C_BusNameVanishedCallback)
mk_BusNameVanishedCallback :: C_BusNameVanishedCallback -> IO (FunPtr C_BusNameVanishedCallback)
noBusNameVanishedCallback :: Maybe BusNameVanishedCallback
noBusNameVanishedCallback_WithClosures :: Maybe BusNameVanishedCallback_WithClosures
wrap_BusNameVanishedCallback :: Maybe (Ptr (FunPtr C_BusNameVanishedCallback)) -> BusNameVanishedCallback_WithClosures -> C_BusNameVanishedCallback
type C_CancellableSourceFunc = Ptr Cancellable -> Ptr () -> IO CInt
type CancellableSourceFunc = Maybe Cancellable -> IO Bool
type CancellableSourceFunc_WithClosures = Maybe Cancellable -> Ptr () -> IO Bool
drop_closures_CancellableSourceFunc :: CancellableSourceFunc -> CancellableSourceFunc_WithClosures
dynamic_CancellableSourceFunc :: (HasCallStack, MonadIO m, IsCancellable a) => FunPtr C_CancellableSourceFunc -> Maybe a -> Ptr () -> m Bool
genClosure_CancellableSourceFunc :: MonadIO m => CancellableSourceFunc -> m (GClosure C_CancellableSourceFunc)
mk_CancellableSourceFunc :: C_CancellableSourceFunc -> IO (FunPtr C_CancellableSourceFunc)
noCancellableSourceFunc :: Maybe CancellableSourceFunc
noCancellableSourceFunc_WithClosures :: Maybe CancellableSourceFunc_WithClosures
wrap_CancellableSourceFunc :: Maybe (Ptr (FunPtr C_CancellableSourceFunc)) -> CancellableSourceFunc_WithClosures -> C_CancellableSourceFunc
type C_DBusInterfaceGetPropertyFunc = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr GError -> Ptr () -> IO (Ptr GVariant)
type DBusInterfaceGetPropertyFunc = DBusConnection -> Text -> Text -> Text -> Text -> GError -> IO GVariant
type DBusInterfaceGetPropertyFunc_WithClosures = DBusConnection -> Text -> Text -> Text -> Text -> GError -> Ptr () -> IO GVariant
drop_closures_DBusInterfaceGetPropertyFunc :: DBusInterfaceGetPropertyFunc -> DBusInterfaceGetPropertyFunc_WithClosures
dynamic_DBusInterfaceGetPropertyFunc :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_DBusInterfaceGetPropertyFunc -> a -> Text -> Text -> Text -> Text -> GError -> Ptr () -> m GVariant
genClosure_DBusInterfaceGetPropertyFunc :: MonadIO m => DBusInterfaceGetPropertyFunc -> m (GClosure C_DBusInterfaceGetPropertyFunc)
mk_DBusInterfaceGetPropertyFunc :: C_DBusInterfaceGetPropertyFunc -> IO (FunPtr C_DBusInterfaceGetPropertyFunc)
noDBusInterfaceGetPropertyFunc :: Maybe DBusInterfaceGetPropertyFunc
noDBusInterfaceGetPropertyFunc_WithClosures :: Maybe DBusInterfaceGetPropertyFunc_WithClosures
wrap_DBusInterfaceGetPropertyFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceGetPropertyFunc)) -> DBusInterfaceGetPropertyFunc_WithClosures -> C_DBusInterfaceGetPropertyFunc
type C_DBusInterfaceMethodCallFunc = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr GVariant -> Ptr DBusMethodInvocation -> Ptr () -> IO ()
type DBusInterfaceMethodCallFunc = DBusConnection -> Text -> Text -> Text -> Text -> GVariant -> DBusMethodInvocation -> IO ()
type DBusInterfaceMethodCallFunc_WithClosures = DBusConnection -> Text -> Text -> Text -> Text -> GVariant -> DBusMethodInvocation -> Ptr () -> IO ()
drop_closures_DBusInterfaceMethodCallFunc :: DBusInterfaceMethodCallFunc -> DBusInterfaceMethodCallFunc_WithClosures
dynamic_DBusInterfaceMethodCallFunc :: (HasCallStack, MonadIO m, IsDBusConnection a, IsDBusMethodInvocation b) => FunPtr C_DBusInterfaceMethodCallFunc -> a -> Text -> Text -> Text -> Text -> GVariant -> b -> Ptr () -> m ()
genClosure_DBusInterfaceMethodCallFunc :: MonadIO m => DBusInterfaceMethodCallFunc -> m (GClosure C_DBusInterfaceMethodCallFunc)
mk_DBusInterfaceMethodCallFunc :: C_DBusInterfaceMethodCallFunc -> IO (FunPtr C_DBusInterfaceMethodCallFunc)
noDBusInterfaceMethodCallFunc :: Maybe DBusInterfaceMethodCallFunc
noDBusInterfaceMethodCallFunc_WithClosures :: Maybe DBusInterfaceMethodCallFunc_WithClosures
wrap_DBusInterfaceMethodCallFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceMethodCallFunc)) -> DBusInterfaceMethodCallFunc_WithClosures -> C_DBusInterfaceMethodCallFunc
type C_DBusInterfaceSetPropertyFunc = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr GVariant -> Ptr GError -> Ptr () -> IO CInt
type DBusInterfaceSetPropertyFunc = DBusConnection -> Text -> Text -> Text -> Text -> GVariant -> GError -> IO Bool
type DBusInterfaceSetPropertyFunc_WithClosures = DBusConnection -> Text -> Text -> Text -> Text -> GVariant -> GError -> Ptr () -> IO Bool
drop_closures_DBusInterfaceSetPropertyFunc :: DBusInterfaceSetPropertyFunc -> DBusInterfaceSetPropertyFunc_WithClosures
dynamic_DBusInterfaceSetPropertyFunc :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_DBusInterfaceSetPropertyFunc -> a -> Text -> Text -> Text -> Text -> GVariant -> GError -> Ptr () -> m Bool
genClosure_DBusInterfaceSetPropertyFunc :: MonadIO m => DBusInterfaceSetPropertyFunc -> m (GClosure C_DBusInterfaceSetPropertyFunc)
mk_DBusInterfaceSetPropertyFunc :: C_DBusInterfaceSetPropertyFunc -> IO (FunPtr C_DBusInterfaceSetPropertyFunc)
noDBusInterfaceSetPropertyFunc :: Maybe DBusInterfaceSetPropertyFunc
noDBusInterfaceSetPropertyFunc_WithClosures :: Maybe DBusInterfaceSetPropertyFunc_WithClosures
wrap_DBusInterfaceSetPropertyFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceSetPropertyFunc)) -> DBusInterfaceSetPropertyFunc_WithClosures -> C_DBusInterfaceSetPropertyFunc
type C_DBusMessageFilterFunction = Ptr DBusConnection -> Ptr DBusMessage -> CInt -> Ptr () -> IO (Ptr DBusMessage)
type DBusMessageFilterFunction = DBusConnection -> DBusMessage -> Bool -> IO (Maybe DBusMessage)
type DBusMessageFilterFunction_WithClosures = DBusConnection -> DBusMessage -> Bool -> Ptr () -> IO (Maybe DBusMessage)
drop_closures_DBusMessageFilterFunction :: DBusMessageFilterFunction -> DBusMessageFilterFunction_WithClosures
dynamic_DBusMessageFilterFunction :: (HasCallStack, MonadIO m, IsDBusConnection a, IsDBusMessage b) => FunPtr C_DBusMessageFilterFunction -> a -> b -> Bool -> Ptr () -> m (Maybe DBusMessage)
genClosure_DBusMessageFilterFunction :: MonadIO m => DBusMessageFilterFunction -> m (GClosure C_DBusMessageFilterFunction)
mk_DBusMessageFilterFunction :: C_DBusMessageFilterFunction -> IO (FunPtr C_DBusMessageFilterFunction)
noDBusMessageFilterFunction :: Maybe DBusMessageFilterFunction
noDBusMessageFilterFunction_WithClosures :: Maybe DBusMessageFilterFunction_WithClosures
wrap_DBusMessageFilterFunction :: Maybe (Ptr (FunPtr C_DBusMessageFilterFunction)) -> DBusMessageFilterFunction_WithClosures -> C_DBusMessageFilterFunction
type C_DBusProxyTypeFunc = Ptr DBusObjectManagerClient -> CString -> CString -> Ptr () -> IO CGType
type DBusProxyTypeFunc = DBusObjectManagerClient -> Text -> Maybe Text -> IO GType
type DBusProxyTypeFunc_WithClosures = DBusObjectManagerClient -> Text -> Maybe Text -> Ptr () -> IO GType
drop_closures_DBusProxyTypeFunc :: DBusProxyTypeFunc -> DBusProxyTypeFunc_WithClosures
dynamic_DBusProxyTypeFunc :: (HasCallStack, MonadIO m, IsDBusObjectManagerClient a) => FunPtr C_DBusProxyTypeFunc -> a -> Text -> Maybe Text -> Ptr () -> m GType
genClosure_DBusProxyTypeFunc :: MonadIO m => DBusProxyTypeFunc -> m (GClosure C_DBusProxyTypeFunc)
mk_DBusProxyTypeFunc :: C_DBusProxyTypeFunc -> IO (FunPtr C_DBusProxyTypeFunc)
noDBusProxyTypeFunc :: Maybe DBusProxyTypeFunc
noDBusProxyTypeFunc_WithClosures :: Maybe DBusProxyTypeFunc_WithClosures
wrap_DBusProxyTypeFunc :: Maybe (Ptr (FunPtr C_DBusProxyTypeFunc)) -> DBusProxyTypeFunc_WithClosures -> C_DBusProxyTypeFunc
type C_DBusSignalCallback = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr GVariant -> Ptr () -> IO ()
type DBusSignalCallback = DBusConnection -> Maybe Text -> Text -> Text -> Text -> GVariant -> IO ()
type DBusSignalCallback_WithClosures = DBusConnection -> Maybe Text -> Text -> Text -> Text -> GVariant -> Ptr () -> IO ()
drop_closures_DBusSignalCallback :: DBusSignalCallback -> DBusSignalCallback_WithClosures
dynamic_DBusSignalCallback :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_DBusSignalCallback -> a -> Maybe Text -> Text -> Text -> Text -> GVariant -> Ptr () -> m ()
genClosure_DBusSignalCallback :: MonadIO m => DBusSignalCallback -> m (GClosure C_DBusSignalCallback)
mk_DBusSignalCallback :: C_DBusSignalCallback -> IO (FunPtr C_DBusSignalCallback)
noDBusSignalCallback :: Maybe DBusSignalCallback
noDBusSignalCallback_WithClosures :: Maybe DBusSignalCallback_WithClosures
wrap_DBusSignalCallback :: Maybe (Ptr (FunPtr C_DBusSignalCallback)) -> DBusSignalCallback_WithClosures -> C_DBusSignalCallback
type C_DBusSubtreeDispatchFunc = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr () -> Ptr () -> IO (Ptr DBusInterfaceVTable)
type DBusSubtreeDispatchFunc = DBusConnection -> Text -> Text -> Text -> Text -> Ptr () -> IO (Maybe DBusInterfaceVTable)
type DBusSubtreeDispatchFunc_WithClosures = DBusConnection -> Text -> Text -> Text -> Text -> Ptr () -> Ptr () -> IO (Maybe DBusInterfaceVTable)
drop_closures_DBusSubtreeDispatchFunc :: DBusSubtreeDispatchFunc -> DBusSubtreeDispatchFunc_WithClosures
dynamic_DBusSubtreeDispatchFunc :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_DBusSubtreeDispatchFunc -> a -> Text -> Text -> Text -> Text -> Ptr () -> Ptr () -> m (Maybe DBusInterfaceVTable)
genClosure_DBusSubtreeDispatchFunc :: MonadIO m => DBusSubtreeDispatchFunc -> m (GClosure C_DBusSubtreeDispatchFunc)
mk_DBusSubtreeDispatchFunc :: C_DBusSubtreeDispatchFunc -> IO (FunPtr C_DBusSubtreeDispatchFunc)
noDBusSubtreeDispatchFunc :: Maybe DBusSubtreeDispatchFunc
noDBusSubtreeDispatchFunc_WithClosures :: Maybe DBusSubtreeDispatchFunc_WithClosures
wrap_DBusSubtreeDispatchFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeDispatchFunc)) -> DBusSubtreeDispatchFunc_WithClosures -> C_DBusSubtreeDispatchFunc
type C_DBusSubtreeEnumerateFunc = Ptr DBusConnection -> CString -> CString -> Ptr () -> IO (Ptr CString)
type DBusSubtreeEnumerateFunc = DBusConnection -> Text -> Text -> IO [Text]
type DBusSubtreeEnumerateFunc_WithClosures = DBusConnection -> Text -> Text -> Ptr () -> IO [Text]
drop_closures_DBusSubtreeEnumerateFunc :: DBusSubtreeEnumerateFunc -> DBusSubtreeEnumerateFunc_WithClosures
dynamic_DBusSubtreeEnumerateFunc :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_DBusSubtreeEnumerateFunc -> a -> Text -> Text -> Ptr () -> m [Text]
genClosure_DBusSubtreeEnumerateFunc :: MonadIO m => DBusSubtreeEnumerateFunc -> m (GClosure C_DBusSubtreeEnumerateFunc)
mk_DBusSubtreeEnumerateFunc :: C_DBusSubtreeEnumerateFunc -> IO (FunPtr C_DBusSubtreeEnumerateFunc)
noDBusSubtreeEnumerateFunc :: Maybe DBusSubtreeEnumerateFunc
noDBusSubtreeEnumerateFunc_WithClosures :: Maybe DBusSubtreeEnumerateFunc_WithClosures
wrap_DBusSubtreeEnumerateFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeEnumerateFunc)) -> DBusSubtreeEnumerateFunc_WithClosures -> C_DBusSubtreeEnumerateFunc
type C_DBusSubtreeIntrospectFunc = Ptr DBusConnection -> CString -> CString -> CString -> Ptr () -> IO (Ptr (Ptr DBusInterfaceInfo))
type DBusSubtreeIntrospectFunc = DBusConnection -> Text -> Text -> Text -> IO (Maybe [DBusInterfaceInfo])
type DBusSubtreeIntrospectFunc_WithClosures = DBusConnection -> Text -> Text -> Text -> Ptr () -> IO (Maybe [DBusInterfaceInfo])
drop_closures_DBusSubtreeIntrospectFunc :: DBusSubtreeIntrospectFunc -> DBusSubtreeIntrospectFunc_WithClosures
dynamic_DBusSubtreeIntrospectFunc :: (HasCallStack, MonadIO m, IsDBusConnection a) => FunPtr C_DBusSubtreeIntrospectFunc -> a -> Text -> Text -> Text -> Ptr () -> m (Maybe [DBusInterfaceInfo])
genClosure_DBusSubtreeIntrospectFunc :: MonadIO m => DBusSubtreeIntrospectFunc -> m (GClosure C_DBusSubtreeIntrospectFunc)
mk_DBusSubtreeIntrospectFunc :: C_DBusSubtreeIntrospectFunc -> IO (FunPtr C_DBusSubtreeIntrospectFunc)
noDBusSubtreeIntrospectFunc :: Maybe DBusSubtreeIntrospectFunc
noDBusSubtreeIntrospectFunc_WithClosures :: Maybe DBusSubtreeIntrospectFunc_WithClosures
wrap_DBusSubtreeIntrospectFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeIntrospectFunc)) -> DBusSubtreeIntrospectFunc_WithClosures -> C_DBusSubtreeIntrospectFunc
type C_DatagramBasedSourceFunc = Ptr DatagramBased -> CUInt -> Ptr () -> IO CInt
type DatagramBasedSourceFunc = DatagramBased -> [IOCondition] -> IO Bool
type DatagramBasedSourceFunc_WithClosures = DatagramBased -> [IOCondition] -> Ptr () -> IO Bool
drop_closures_DatagramBasedSourceFunc :: DatagramBasedSourceFunc -> DatagramBasedSourceFunc_WithClosures
dynamic_DatagramBasedSourceFunc :: (HasCallStack, MonadIO m, IsDatagramBased a) => FunPtr C_DatagramBasedSourceFunc -> a -> [IOCondition] -> Ptr () -> m Bool
genClosure_DatagramBasedSourceFunc :: MonadIO m => DatagramBasedSourceFunc -> m (GClosure C_DatagramBasedSourceFunc)
mk_DatagramBasedSourceFunc :: C_DatagramBasedSourceFunc -> IO (FunPtr C_DatagramBasedSourceFunc)
noDatagramBasedSourceFunc :: Maybe DatagramBasedSourceFunc
noDatagramBasedSourceFunc_WithClosures :: Maybe DatagramBasedSourceFunc_WithClosures
wrap_DatagramBasedSourceFunc :: Maybe (Ptr (FunPtr C_DatagramBasedSourceFunc)) -> DatagramBasedSourceFunc_WithClosures -> C_DatagramBasedSourceFunc
type C_DesktopAppLaunchCallback = Ptr DesktopAppInfo -> Int32 -> Ptr () -> IO ()
type DesktopAppLaunchCallback = DesktopAppInfo -> Int32 -> IO ()
type DesktopAppLaunchCallback_WithClosures = DesktopAppInfo -> Int32 -> Ptr () -> IO ()
drop_closures_DesktopAppLaunchCallback :: DesktopAppLaunchCallback -> DesktopAppLaunchCallback_WithClosures
dynamic_DesktopAppLaunchCallback :: (HasCallStack, MonadIO m, IsDesktopAppInfo a) => FunPtr C_DesktopAppLaunchCallback -> a -> Int32 -> Ptr () -> m ()
genClosure_DesktopAppLaunchCallback :: MonadIO m => DesktopAppLaunchCallback -> m (GClosure C_DesktopAppLaunchCallback)
mk_DesktopAppLaunchCallback :: C_DesktopAppLaunchCallback -> IO (FunPtr C_DesktopAppLaunchCallback)
noDesktopAppLaunchCallback :: Maybe DesktopAppLaunchCallback
noDesktopAppLaunchCallback_WithClosures :: Maybe DesktopAppLaunchCallback_WithClosures
wrap_DesktopAppLaunchCallback :: Maybe (Ptr (FunPtr C_DesktopAppLaunchCallback)) -> DesktopAppLaunchCallback_WithClosures -> C_DesktopAppLaunchCallback
type C_FileMeasureProgressCallback = CInt -> Word64 -> Word64 -> Word64 -> Ptr () -> IO ()
type FileMeasureProgressCallback = Bool -> Word64 -> Word64 -> Word64 -> IO ()
type FileMeasureProgressCallback_WithClosures = Bool -> Word64 -> Word64 -> Word64 -> Ptr () -> IO ()
drop_closures_FileMeasureProgressCallback :: FileMeasureProgressCallback -> FileMeasureProgressCallback_WithClosures
dynamic_FileMeasureProgressCallback :: (HasCallStack, MonadIO m) => FunPtr C_FileMeasureProgressCallback -> Bool -> Word64 -> Word64 -> Word64 -> Ptr () -> m ()
genClosure_FileMeasureProgressCallback :: MonadIO m => FileMeasureProgressCallback -> m (GClosure C_FileMeasureProgressCallback)
mk_FileMeasureProgressCallback :: C_FileMeasureProgressCallback -> IO (FunPtr C_FileMeasureProgressCallback)
noFileMeasureProgressCallback :: Maybe FileMeasureProgressCallback
noFileMeasureProgressCallback_WithClosures :: Maybe FileMeasureProgressCallback_WithClosures
wrap_FileMeasureProgressCallback :: Maybe (Ptr (FunPtr C_FileMeasureProgressCallback)) -> FileMeasureProgressCallback_WithClosures -> C_FileMeasureProgressCallback
type C_FileProgressCallback = Int64 -> Int64 -> Ptr () -> IO ()
type FileProgressCallback = Int64 -> Int64 -> IO ()
type FileProgressCallback_WithClosures = Int64 -> Int64 -> Ptr () -> IO ()
drop_closures_FileProgressCallback :: FileProgressCallback -> FileProgressCallback_WithClosures
dynamic_FileProgressCallback :: (HasCallStack, MonadIO m) => FunPtr C_FileProgressCallback -> Int64 -> Int64 -> Ptr () -> m ()
genClosure_FileProgressCallback :: MonadIO m => FileProgressCallback -> m (GClosure C_FileProgressCallback)
mk_FileProgressCallback :: C_FileProgressCallback -> IO (FunPtr C_FileProgressCallback)
noFileProgressCallback :: Maybe FileProgressCallback
noFileProgressCallback_WithClosures :: Maybe FileProgressCallback_WithClosures
wrap_FileProgressCallback :: Maybe (Ptr (FunPtr C_FileProgressCallback)) -> FileProgressCallback_WithClosures -> C_FileProgressCallback
type C_FileReadMoreCallback = CString -> Int64 -> Ptr () -> IO CInt
type FileReadMoreCallback = Text -> Int64 -> IO Bool
type FileReadMoreCallback_WithClosures = Text -> Int64 -> Ptr () -> IO Bool
drop_closures_FileReadMoreCallback :: FileReadMoreCallback -> FileReadMoreCallback_WithClosures
dynamic_FileReadMoreCallback :: (HasCallStack, MonadIO m) => FunPtr C_FileReadMoreCallback -> Text -> Int64 -> Ptr () -> m Bool
genClosure_FileReadMoreCallback :: MonadIO m => FileReadMoreCallback -> m (GClosure C_FileReadMoreCallback)
mk_FileReadMoreCallback :: C_FileReadMoreCallback -> IO (FunPtr C_FileReadMoreCallback)
noFileReadMoreCallback :: Maybe FileReadMoreCallback
noFileReadMoreCallback_WithClosures :: Maybe FileReadMoreCallback_WithClosures
wrap_FileReadMoreCallback :: Maybe (Ptr (FunPtr C_FileReadMoreCallback)) -> FileReadMoreCallback_WithClosures -> C_FileReadMoreCallback
type C_IOSchedulerJobFunc = Ptr IOSchedulerJob -> Ptr Cancellable -> Ptr () -> IO CInt
type IOSchedulerJobFunc = IOSchedulerJob -> Maybe Cancellable -> IO Bool
type IOSchedulerJobFunc_WithClosures = IOSchedulerJob -> Maybe Cancellable -> Ptr () -> IO Bool
drop_closures_IOSchedulerJobFunc :: IOSchedulerJobFunc -> IOSchedulerJobFunc_WithClosures
dynamic_IOSchedulerJobFunc :: (HasCallStack, MonadIO m, IsCancellable a) => FunPtr C_IOSchedulerJobFunc -> IOSchedulerJob -> Maybe a -> Ptr () -> m Bool
genClosure_IOSchedulerJobFunc :: MonadIO m => IOSchedulerJobFunc -> m (GClosure C_IOSchedulerJobFunc)
mk_IOSchedulerJobFunc :: C_IOSchedulerJobFunc -> IO (FunPtr C_IOSchedulerJobFunc)
noIOSchedulerJobFunc :: Maybe IOSchedulerJobFunc
noIOSchedulerJobFunc_WithClosures :: Maybe IOSchedulerJobFunc_WithClosures
wrap_IOSchedulerJobFunc :: Maybe (Ptr (FunPtr C_IOSchedulerJobFunc)) -> IOSchedulerJobFunc_WithClosures -> C_IOSchedulerJobFunc
type C_InputStreamClassCloseAsyncFieldCallback = Ptr InputStream -> Int32 -> Ptr Cancellable -> FunPtr C_AsyncReadyCallback -> Ptr () -> IO ()
type InputStreamClassCloseAsyncFieldCallback = InputStream -> Int32 -> Maybe Cancellable -> Maybe AsyncReadyCallback_WithClosures -> IO ()
type InputStreamClassCloseAsyncFieldCallback_WithClosures = InputStream -> Int32 -> Maybe Cancellable -> Maybe AsyncReadyCallback_WithClosures -> Ptr () -> IO ()
drop_closures_InputStreamClassCloseAsyncFieldCallback :: InputStreamClassCloseAsyncFieldCallback -> InputStreamClassCloseAsyncFieldCallback_WithClosures
dynamic_InputStreamClassCloseAsyncFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) => FunPtr C_InputStreamClassCloseAsyncFieldCallback -> a -> Int32 -> Maybe b -> Maybe AsyncReadyCallback_WithClosures -> Ptr () -> m ()
genClosure_InputStreamClassCloseAsyncFieldCallback :: MonadIO m => InputStreamClassCloseAsyncFieldCallback -> m (GClosure C_InputStreamClassCloseAsyncFieldCallback)
mk_InputStreamClassCloseAsyncFieldCallback :: C_InputStreamClassCloseAsyncFieldCallback -> IO (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
noInputStreamClassCloseAsyncFieldCallback :: Maybe InputStreamClassCloseAsyncFieldCallback
noInputStreamClassCloseAsyncFieldCallback_WithClosures :: Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
wrap_InputStreamClassCloseAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)) -> InputStreamClassCloseAsyncFieldCallback_WithClosures -> C_InputStreamClassCloseAsyncFieldCallback
type C_InputStreamClassCloseFinishFieldCallback = Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
type InputStreamClassCloseFinishFieldCallback = InputStream -> AsyncResult -> IO ()
dynamic_InputStreamClassCloseFinishFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) => FunPtr C_InputStreamClassCloseFinishFieldCallback -> a -> b -> m ()
mk_InputStreamClassCloseFinishFieldCallback :: C_InputStreamClassCloseFinishFieldCallback -> IO (FunPtr C_InputStreamClassCloseFinishFieldCallback)
noInputStreamClassCloseFinishFieldCallback :: Maybe InputStreamClassCloseFinishFieldCallback
type C_InputStreamClassCloseFnFieldCallback = Ptr InputStream -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
type InputStreamClassCloseFnFieldCallback = InputStream -> Maybe Cancellable -> IO ()
dynamic_InputStreamClassCloseFnFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) => FunPtr C_InputStreamClassCloseFnFieldCallback -> a -> Maybe b -> m ()
mk_InputStreamClassCloseFnFieldCallback :: C_InputStreamClassCloseFnFieldCallback -> IO (FunPtr C_InputStreamClassCloseFnFieldCallback)
noInputStreamClassCloseFnFieldCallback :: Maybe InputStreamClassCloseFnFieldCallback
type C_InputStreamClassReadAsyncFieldCallback = Ptr InputStream -> Ptr Word8 -> CSize -> Int32 -> Ptr Cancellable -> FunPtr C_AsyncReadyCallback -> Ptr () -> IO ()
type InputStreamClassReadAsyncFieldCallback = InputStream -> Maybe ByteString -> Int32 -> Maybe Cancellable -> Maybe AsyncReadyCallback_WithClosures -> IO (Maybe ByteString)
type InputStreamClassReadAsyncFieldCallback_WithClosures = InputStream -> Maybe ByteString -> Int32 -> Maybe Cancellable -> Maybe AsyncReadyCallback_WithClosures -> Ptr () -> IO (Maybe ByteString)
drop_closures_InputStreamClassReadAsyncFieldCallback :: InputStreamClassReadAsyncFieldCallback -> InputStreamClassReadAsyncFieldCallback_WithClosures
dynamic_InputStreamClassReadAsyncFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) => FunPtr C_InputStreamClassReadAsyncFieldCallback -> a -> Maybe ByteString -> Int32 -> Maybe b -> Maybe AsyncReadyCallback_WithClosures -> Ptr () -> m (Maybe ByteString)
genClosure_InputStreamClassReadAsyncFieldCallback :: MonadIO m => InputStreamClassReadAsyncFieldCallback -> m (GClosure C_InputStreamClassReadAsyncFieldCallback)
mk_InputStreamClassReadAsyncFieldCallback :: C_InputStreamClassReadAsyncFieldCallback -> IO (FunPtr C_InputStreamClassReadAsyncFieldCallback)
noInputStreamClassReadAsyncFieldCallback :: Maybe InputStreamClassReadAsyncFieldCallback
noInputStreamClassReadAsyncFieldCallback_WithClosures :: Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
wrap_InputStreamClassReadAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)) -> InputStreamClassReadAsyncFieldCallback_WithClosures -> C_InputStreamClassReadAsyncFieldCallback
type C_InputStreamClassReadFinishFieldCallback = Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO Int64
type InputStreamClassReadFinishFieldCallback = InputStream -> AsyncResult -> IO Int64
dynamic_InputStreamClassReadFinishFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) => FunPtr C_InputStreamClassReadFinishFieldCallback -> a -> b -> m Int64
mk_InputStreamClassReadFinishFieldCallback :: C_InputStreamClassReadFinishFieldCallback -> IO (FunPtr C_InputStreamClassReadFinishFieldCallback)
noInputStreamClassReadFinishFieldCallback :: Maybe InputStreamClassReadFinishFieldCallback
type C_InputStreamClassReadFnFieldCallback = Ptr InputStream -> Ptr () -> CSize -> Ptr Cancellable -> Ptr (Ptr GError) -> IO Int64
type InputStreamClassReadFnFieldCallback = InputStream -> Ptr () -> CSize -> Maybe Cancellable -> IO Int64
dynamic_InputStreamClassReadFnFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) => FunPtr C_InputStreamClassReadFnFieldCallback -> a -> Ptr () -> CSize -> Maybe b -> m Int64
mk_InputStreamClassReadFnFieldCallback :: C_InputStreamClassReadFnFieldCallback -> IO (FunPtr C_InputStreamClassReadFnFieldCallback)
noInputStreamClassReadFnFieldCallback :: Maybe InputStreamClassReadFnFieldCallback
type C_InputStreamClassSkipAsyncFieldCallback = Ptr InputStream -> CSize -> Int32 -> Ptr Cancellable -> FunPtr C_AsyncReadyCallback -> Ptr () -> IO ()
type InputStreamClassSkipAsyncFieldCallback = InputStream -> CSize -> Int32 -> Maybe Cancellable -> Maybe AsyncReadyCallback_WithClosures -> IO ()
type InputStreamClassSkipAsyncFieldCallback_WithClosures = InputStream -> CSize -> Int32 -> Maybe Cancellable -> Maybe AsyncReadyCallback_WithClosures -> Ptr () -> IO ()
drop_closures_InputStreamClassSkipAsyncFieldCallback :: InputStreamClassSkipAsyncFieldCallback -> InputStreamClassSkipAsyncFieldCallback_WithClosures
dynamic_InputStreamClassSkipAsyncFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) => FunPtr C_InputStreamClassSkipAsyncFieldCallback -> a -> CSize -> Int32 -> Maybe b -> Maybe AsyncReadyCallback_WithClosures -> Ptr () -> m ()
genClosure_InputStreamClassSkipAsyncFieldCallback :: MonadIO m => InputStreamClassSkipAsyncFieldCallback -> m (GClosure C_InputStreamClassSkipAsyncFieldCallback)
mk_InputStreamClassSkipAsyncFieldCallback :: C_InputStreamClassSkipAsyncFieldCallback -> IO (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
noInputStreamClassSkipAsyncFieldCallback :: Maybe InputStreamClassSkipAsyncFieldCallback
noInputStreamClassSkipAsyncFieldCallback_WithClosures :: Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
wrap_InputStreamClassSkipAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)) -> InputStreamClassSkipAsyncFieldCallback_WithClosures -> C_InputStreamClassSkipAsyncFieldCallback
type C_InputStreamClassSkipFieldCallback = Ptr InputStream -> CSize -> Ptr Cancellable -> Ptr (Ptr GError) -> IO Int64
type InputStreamClassSkipFieldCallback = InputStream -> CSize -> Maybe Cancellable -> IO Int64
dynamic_InputStreamClassSkipFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) => FunPtr C_InputStreamClassSkipFieldCallback -> a -> CSize -> Maybe b -> m Int64
mk_InputStreamClassSkipFieldCallback :: C_InputStreamClassSkipFieldCallback -> IO (FunPtr C_InputStreamClassSkipFieldCallback)
noInputStreamClassSkipFieldCallback :: Maybe InputStreamClassSkipFieldCallback
type C_InputStreamClassSkipFinishFieldCallback = Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO Int64
type InputStreamClassSkipFinishFieldCallback = InputStream -> AsyncResult -> IO Int64
dynamic_InputStreamClassSkipFinishFieldCallback :: (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) => FunPtr C_InputStreamClassSkipFinishFieldCallback -> a -> b -> m Int64
mk_InputStreamClassSkipFinishFieldCallback :: C_InputStreamClassSkipFinishFieldCallback -> IO (FunPtr C_InputStreamClassSkipFinishFieldCallback)
noInputStreamClassSkipFinishFieldCallback :: Maybe InputStreamClassSkipFinishFieldCallback
type C_PollableSourceFunc = Ptr Object -> Ptr () -> IO CInt
type PollableSourceFunc = Object -> IO Bool
type PollableSourceFunc_WithClosures = Object -> Ptr () -> IO Bool
drop_closures_PollableSourceFunc :: PollableSourceFunc -> PollableSourceFunc_WithClosures
dynamic_PollableSourceFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_PollableSourceFunc -> a -> Ptr () -> m Bool
genClosure_PollableSourceFunc :: MonadIO m => PollableSourceFunc -> m (GClosure C_PollableSourceFunc)
mk_PollableSourceFunc :: C_PollableSourceFunc -> IO (FunPtr C_PollableSourceFunc)
noPollableSourceFunc :: Maybe PollableSourceFunc
noPollableSourceFunc_WithClosures :: Maybe PollableSourceFunc_WithClosures
wrap_PollableSourceFunc :: Maybe (Ptr (FunPtr C_PollableSourceFunc)) -> PollableSourceFunc_WithClosures -> C_PollableSourceFunc
type C_ReallocFunc = Ptr () -> CSize -> IO (Ptr ())
type ReallocFunc = Ptr () -> CSize -> IO (Ptr ())
dynamic_ReallocFunc :: (HasCallStack, MonadIO m) => FunPtr C_ReallocFunc -> Ptr () -> CSize -> m (Ptr ())
genClosure_ReallocFunc :: MonadIO m => ReallocFunc -> m (GClosure C_ReallocFunc)
mk_ReallocFunc :: C_ReallocFunc -> IO (FunPtr C_ReallocFunc)
noReallocFunc :: Maybe ReallocFunc
wrap_ReallocFunc :: Maybe (Ptr (FunPtr C_ReallocFunc)) -> ReallocFunc -> C_ReallocFunc
type C_SeekableIfaceCanSeekFieldCallback = Ptr Seekable -> IO CInt
type SeekableIfaceCanSeekFieldCallback = Seekable -> IO Bool
dynamic_SeekableIfaceCanSeekFieldCallback :: (HasCallStack, MonadIO m, IsSeekable a) => FunPtr C_SeekableIfaceCanSeekFieldCallback -> a -> m Bool
genClosure_SeekableIfaceCanSeekFieldCallback :: MonadIO m => SeekableIfaceCanSeekFieldCallback -> m (GClosure C_SeekableIfaceCanSeekFieldCallback)
mk_SeekableIfaceCanSeekFieldCallback :: C_SeekableIfaceCanSeekFieldCallback -> IO (FunPtr C_SeekableIfaceCanSeekFieldCallback)
noSeekableIfaceCanSeekFieldCallback :: Maybe SeekableIfaceCanSeekFieldCallback
wrap_SeekableIfaceCanSeekFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)) -> SeekableIfaceCanSeekFieldCallback -> C_SeekableIfaceCanSeekFieldCallback
type C_SeekableIfaceCanTruncateFieldCallback = Ptr Seekable -> IO CInt
type SeekableIfaceCanTruncateFieldCallback = Seekable -> IO Bool
dynamic_SeekableIfaceCanTruncateFieldCallback :: (HasCallStack, MonadIO m, IsSeekable a) => FunPtr C_SeekableIfaceCanTruncateFieldCallback -> a -> m Bool
genClosure_SeekableIfaceCanTruncateFieldCallback :: MonadIO m => SeekableIfaceCanTruncateFieldCallback -> m (GClosure C_SeekableIfaceCanTruncateFieldCallback)
mk_SeekableIfaceCanTruncateFieldCallback :: C_SeekableIfaceCanTruncateFieldCallback -> IO (FunPtr C_SeekableIfaceCanTruncateFieldCallback)
noSeekableIfaceCanTruncateFieldCallback :: Maybe SeekableIfaceCanTruncateFieldCallback
wrap_SeekableIfaceCanTruncateFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback)) -> SeekableIfaceCanTruncateFieldCallback -> C_SeekableIfaceCanTruncateFieldCallback
type C_SeekableIfaceSeekFieldCallback = Ptr Seekable -> Int64 -> CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
type SeekableIfaceSeekFieldCallback = Seekable -> Int64 -> SeekType -> Maybe Cancellable -> IO ()
dynamic_SeekableIfaceSeekFieldCallback :: (HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) => FunPtr C_SeekableIfaceSeekFieldCallback -> a -> Int64 -> SeekType -> Maybe b -> m ()
mk_SeekableIfaceSeekFieldCallback :: C_SeekableIfaceSeekFieldCallback -> IO (FunPtr C_SeekableIfaceSeekFieldCallback)
noSeekableIfaceSeekFieldCallback :: Maybe SeekableIfaceSeekFieldCallback
type C_SeekableIfaceTellFieldCallback = Ptr Seekable -> IO Int64
type SeekableIfaceTellFieldCallback = Seekable -> IO Int64
dynamic_SeekableIfaceTellFieldCallback :: (HasCallStack, MonadIO m, IsSeekable a) => FunPtr C_SeekableIfaceTellFieldCallback -> a -> m Int64
genClosure_SeekableIfaceTellFieldCallback :: MonadIO m => SeekableIfaceTellFieldCallback -> m (GClosure C_SeekableIfaceTellFieldCallback)
mk_SeekableIfaceTellFieldCallback :: C_SeekableIfaceTellFieldCallback -> IO (FunPtr C_SeekableIfaceTellFieldCallback)
noSeekableIfaceTellFieldCallback :: Maybe SeekableIfaceTellFieldCallback
wrap_SeekableIfaceTellFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceTellFieldCallback)) -> SeekableIfaceTellFieldCallback -> C_SeekableIfaceTellFieldCallback
type C_SeekableIfaceTruncateFnFieldCallback = Ptr Seekable -> Int64 -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
type SeekableIfaceTruncateFnFieldCallback = Seekable -> Int64 -> Maybe Cancellable -> IO ()
dynamic_SeekableIfaceTruncateFnFieldCallback :: (HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) => FunPtr C_SeekableIfaceTruncateFnFieldCallback -> a -> Int64 -> Maybe b -> m ()
mk_SeekableIfaceTruncateFnFieldCallback :: C_SeekableIfaceTruncateFnFieldCallback -> IO (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
noSeekableIfaceTruncateFnFieldCallback :: Maybe SeekableIfaceTruncateFnFieldCallback
type C_SettingsBindGetMapping = Ptr GValue -> Ptr GVariant -> Ptr () -> IO CInt
type SettingsBindGetMapping = GValue -> GVariant -> IO Bool
type SettingsBindGetMapping_WithClosures = GValue -> GVariant -> Ptr () -> IO Bool
drop_closures_SettingsBindGetMapping :: SettingsBindGetMapping -> SettingsBindGetMapping_WithClosures
dynamic_SettingsBindGetMapping :: (HasCallStack, MonadIO m) => FunPtr C_SettingsBindGetMapping -> GValue -> GVariant -> Ptr () -> m Bool
genClosure_SettingsBindGetMapping :: MonadIO m => SettingsBindGetMapping -> m (GClosure C_SettingsBindGetMapping)
mk_SettingsBindGetMapping :: C_SettingsBindGetMapping -> IO (FunPtr C_SettingsBindGetMapping)
noSettingsBindGetMapping :: Maybe SettingsBindGetMapping
noSettingsBindGetMapping_WithClosures :: Maybe SettingsBindGetMapping_WithClosures
wrap_SettingsBindGetMapping :: Maybe (Ptr (FunPtr C_SettingsBindGetMapping)) -> SettingsBindGetMapping_WithClosures -> C_SettingsBindGetMapping
type C_SettingsBindSetMapping = Ptr GValue -> Ptr VariantType -> Ptr () -> IO (Ptr GVariant)
type SettingsBindSetMapping = GValue -> VariantType -> IO GVariant
type SettingsBindSetMapping_WithClosures = GValue -> VariantType -> Ptr () -> IO GVariant
drop_closures_SettingsBindSetMapping :: SettingsBindSetMapping -> SettingsBindSetMapping_WithClosures
dynamic_SettingsBindSetMapping :: (HasCallStack, MonadIO m) => FunPtr C_SettingsBindSetMapping -> GValue -> VariantType -> Ptr () -> m GVariant
genClosure_SettingsBindSetMapping :: MonadIO m => SettingsBindSetMapping -> m (GClosure C_SettingsBindSetMapping)
mk_SettingsBindSetMapping :: C_SettingsBindSetMapping -> IO (FunPtr C_SettingsBindSetMapping)
noSettingsBindSetMapping :: Maybe SettingsBindSetMapping
noSettingsBindSetMapping_WithClosures :: Maybe SettingsBindSetMapping_WithClosures
wrap_SettingsBindSetMapping :: Maybe (Ptr (FunPtr C_SettingsBindSetMapping)) -> SettingsBindSetMapping_WithClosures -> C_SettingsBindSetMapping
type C_SettingsGetMapping = Ptr GVariant -> Ptr (Ptr ()) -> Ptr () -> IO CInt
type SettingsGetMapping = GVariant -> IO (Bool, Ptr ())
type SettingsGetMapping_WithClosures = GVariant -> Ptr () -> IO (Bool, Ptr ())
drop_closures_SettingsGetMapping :: SettingsGetMapping -> SettingsGetMapping_WithClosures
dynamic_SettingsGetMapping :: (HasCallStack, MonadIO m) => FunPtr C_SettingsGetMapping -> GVariant -> Ptr () -> m (Bool, Ptr ())
genClosure_SettingsGetMapping :: MonadIO m => SettingsGetMapping -> m (GClosure C_SettingsGetMapping)
mk_SettingsGetMapping :: C_SettingsGetMapping -> IO (FunPtr C_SettingsGetMapping)
noSettingsGetMapping :: Maybe SettingsGetMapping
noSettingsGetMapping_WithClosures :: Maybe SettingsGetMapping_WithClosures
wrap_SettingsGetMapping :: Maybe (Ptr (FunPtr C_SettingsGetMapping)) -> SettingsGetMapping_WithClosures -> C_SettingsGetMapping
type C_SimpleAsyncThreadFunc = Ptr SimpleAsyncResult -> Ptr Object -> Ptr Cancellable -> IO ()
type SimpleAsyncThreadFunc = SimpleAsyncResult -> Object -> Maybe Cancellable -> IO ()
dynamic_SimpleAsyncThreadFunc :: (HasCallStack, MonadIO m, IsSimpleAsyncResult a, IsObject b, IsCancellable c) => FunPtr C_SimpleAsyncThreadFunc -> a -> b -> Maybe c -> m ()
genClosure_SimpleAsyncThreadFunc :: MonadIO m => SimpleAsyncThreadFunc -> m (GClosure C_SimpleAsyncThreadFunc)
mk_SimpleAsyncThreadFunc :: C_SimpleAsyncThreadFunc -> IO (FunPtr C_SimpleAsyncThreadFunc)
noSimpleAsyncThreadFunc :: Maybe SimpleAsyncThreadFunc
wrap_SimpleAsyncThreadFunc :: Maybe (Ptr (FunPtr C_SimpleAsyncThreadFunc)) -> SimpleAsyncThreadFunc -> C_SimpleAsyncThreadFunc
type C_SocketSourceFunc = Ptr Socket -> CUInt -> Ptr () -> IO CInt
type SocketSourceFunc = Socket -> [IOCondition] -> IO Bool
type SocketSourceFunc_WithClosures = Socket -> [IOCondition] -> Ptr () -> IO Bool
drop_closures_SocketSourceFunc :: SocketSourceFunc -> SocketSourceFunc_WithClosures
dynamic_SocketSourceFunc :: (HasCallStack, MonadIO m, IsSocket a) => FunPtr C_SocketSourceFunc -> a -> [IOCondition] -> Ptr () -> m Bool
genClosure_SocketSourceFunc :: MonadIO m => SocketSourceFunc -> m (GClosure C_SocketSourceFunc)
mk_SocketSourceFunc :: C_SocketSourceFunc -> IO (FunPtr C_SocketSourceFunc)
noSocketSourceFunc :: Maybe SocketSourceFunc
noSocketSourceFunc_WithClosures :: Maybe SocketSourceFunc_WithClosures
wrap_SocketSourceFunc :: Maybe (Ptr (FunPtr C_SocketSourceFunc)) -> SocketSourceFunc_WithClosures -> C_SocketSourceFunc
type C_TaskThreadFunc = Ptr Task -> Ptr Object -> Ptr () -> Ptr Cancellable -> IO ()
type TaskThreadFunc = Task -> Object -> Ptr () -> Maybe Cancellable -> IO ()
dynamic_TaskThreadFunc :: (HasCallStack, MonadIO m, IsTask a, IsObject b, IsCancellable c) => FunPtr C_TaskThreadFunc -> a -> b -> Ptr () -> Maybe c -> m ()
genClosure_TaskThreadFunc :: MonadIO m => TaskThreadFunc -> m (GClosure C_TaskThreadFunc)
mk_TaskThreadFunc :: C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)
noTaskThreadFunc :: Maybe TaskThreadFunc
wrap_TaskThreadFunc :: Maybe (Ptr (FunPtr C_TaskThreadFunc)) -> TaskThreadFunc -> C_TaskThreadFunc
type C_VfsFileLookupFunc = Ptr Vfs -> CString -> Ptr () -> IO (Ptr File)
type VfsFileLookupFunc = Vfs -> Text -> IO File
type VfsFileLookupFunc_WithClosures = Vfs -> Text -> Ptr () -> IO File
drop_closures_VfsFileLookupFunc :: VfsFileLookupFunc -> VfsFileLookupFunc_WithClosures
dynamic_VfsFileLookupFunc :: (HasCallStack, MonadIO m, IsVfs a) => FunPtr C_VfsFileLookupFunc -> a -> Text -> Ptr () -> m File
genClosure_VfsFileLookupFunc :: MonadIO m => VfsFileLookupFunc -> m (GClosure C_VfsFileLookupFunc)
mk_VfsFileLookupFunc :: C_VfsFileLookupFunc -> IO (FunPtr C_VfsFileLookupFunc)
noVfsFileLookupFunc :: Maybe VfsFileLookupFunc
noVfsFileLookupFunc_WithClosures :: Maybe VfsFileLookupFunc_WithClosures
wrap_VfsFileLookupFunc :: Maybe (Ptr (FunPtr C_VfsFileLookupFunc)) -> VfsFileLookupFunc_WithClosures -> C_VfsFileLookupFunc

Signals

ActionEntryActivateFieldCallback

type ActionEntryActivateFieldCallback = SimpleAction -> Maybe GVariant -> IO () Source #

No description available in the introspection data.

type ActionEntryActivateFieldCallback_WithClosures = SimpleAction -> Maybe GVariant -> Ptr () -> IO () Source #

No description available in the introspection data.

type C_ActionEntryActivateFieldCallback = Ptr SimpleAction -> Ptr GVariant -> Ptr () -> IO () Source #

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

drop_closures_ActionEntryActivateFieldCallback :: ActionEntryActivateFieldCallback -> ActionEntryActivateFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ActionEntryActivateFieldCallback :: (HasCallStack, MonadIO m, IsSimpleAction a) => FunPtr C_ActionEntryActivateFieldCallback -> a -> Maybe GVariant -> Ptr () -> m () Source #

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

genClosure_ActionEntryActivateFieldCallback :: MonadIO m => ActionEntryActivateFieldCallback -> m (GClosure C_ActionEntryActivateFieldCallback) Source #

Wrap the callback into a GClosure.

mk_ActionEntryActivateFieldCallback :: C_ActionEntryActivateFieldCallback -> IO (FunPtr C_ActionEntryActivateFieldCallback) Source #

Generate a function pointer callable from C code, from a C_ActionEntryActivateFieldCallback.

noActionEntryActivateFieldCallback :: Maybe ActionEntryActivateFieldCallback Source #

A convenience synonym for Nothing :: Maybe ActionEntryActivateFieldCallback.

noActionEntryActivateFieldCallback_WithClosures :: Maybe ActionEntryActivateFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe ActionEntryActivateFieldCallback_WithClosures.

wrap_ActionEntryActivateFieldCallback :: Maybe (Ptr (FunPtr C_ActionEntryActivateFieldCallback)) -> ActionEntryActivateFieldCallback_WithClosures -> C_ActionEntryActivateFieldCallback Source #

Wrap a ActionEntryActivateFieldCallback into a C_ActionEntryActivateFieldCallback.

ActionEntryChangeStateFieldCallback

type ActionEntryChangeStateFieldCallback = SimpleAction -> GVariant -> IO () Source #

No description available in the introspection data.

type ActionEntryChangeStateFieldCallback_WithClosures = SimpleAction -> GVariant -> Ptr () -> IO () Source #

No description available in the introspection data.

type C_ActionEntryChangeStateFieldCallback = Ptr SimpleAction -> Ptr GVariant -> Ptr () -> IO () Source #

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

drop_closures_ActionEntryChangeStateFieldCallback :: ActionEntryChangeStateFieldCallback -> ActionEntryChangeStateFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_ActionEntryChangeStateFieldCallback :: (HasCallStack, MonadIO m, IsSimpleAction a) => FunPtr C_ActionEntryChangeStateFieldCallback -> a -> GVariant -> Ptr () -> m () Source #

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

genClosure_ActionEntryChangeStateFieldCallback :: MonadIO m => ActionEntryChangeStateFieldCallback -> m (GClosure C_ActionEntryChangeStateFieldCallback) Source #

Wrap the callback into a GClosure.

mk_ActionEntryChangeStateFieldCallback :: C_ActionEntryChangeStateFieldCallback -> IO (FunPtr C_ActionEntryChangeStateFieldCallback) Source #

Generate a function pointer callable from C code, from a C_ActionEntryChangeStateFieldCallback.

noActionEntryChangeStateFieldCallback :: Maybe ActionEntryChangeStateFieldCallback Source #

A convenience synonym for Nothing :: Maybe ActionEntryChangeStateFieldCallback.

noActionEntryChangeStateFieldCallback_WithClosures :: Maybe ActionEntryChangeStateFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe ActionEntryChangeStateFieldCallback_WithClosures.

wrap_ActionEntryChangeStateFieldCallback :: Maybe (Ptr (FunPtr C_ActionEntryChangeStateFieldCallback)) -> ActionEntryChangeStateFieldCallback_WithClosures -> C_ActionEntryChangeStateFieldCallback Source #

Wrap a ActionEntryChangeStateFieldCallback into a C_ActionEntryChangeStateFieldCallback.

AsyncReadyCallback

type AsyncReadyCallback Source #

Arguments

= Maybe Object	`sourceObject`: the object the asynchronous operation was started with.
-> AsyncResult	`res`: a `AsyncResult`.
-> IO ()

Type definition for a function that will be called back when an asynchronous operation within GIO has been completed. AsyncReadyCallback callbacks from Task are guaranteed to be invoked in a later iteration of the [thread-default main context][g-main-context-push-thread-default] where the Task was created. All other users of AsyncReadyCallback must likewise call it asynchronously in a later iteration of the main context.

The asynchronous operation is guaranteed to have held a reference to sourceObject from the time when the *_async() function was called, until after this callback returns.

type AsyncReadyCallback_WithClosures Source #

Arguments

= Maybe Object	`sourceObject`: the object the asynchronous operation was started with.
-> AsyncResult	`res`: a `AsyncResult`.
-> Ptr ()	`data`: user data passed to the callback.
-> IO ()

Type definition for a function that will be called back when an asynchronous operation within GIO has been completed. AsyncReadyCallback callbacks from Task are guaranteed to be invoked in a later iteration of the [thread-default main context][g-main-context-push-thread-default] where the Task was created. All other users of AsyncReadyCallback must likewise call it asynchronously in a later iteration of the main context.

The asynchronous operation is guaranteed to have held a reference to sourceObject from the time when the *_async() function was called, until after this callback returns.

type C_AsyncReadyCallback = Ptr Object -> Ptr AsyncResult -> Ptr () -> IO () Source #

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

drop_closures_AsyncReadyCallback :: AsyncReadyCallback -> AsyncReadyCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_AsyncReadyCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a, IsAsyncResult b)
=> FunPtr C_AsyncReadyCallback
-> Maybe a	`sourceObject`: the object the asynchronous operation was started with.
-> b	`res`: a `AsyncResult`.
-> Ptr ()	`data`: user data passed to the callback.
-> m ()

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

genClosure_AsyncReadyCallback :: MonadIO m => AsyncReadyCallback -> m (GClosure C_AsyncReadyCallback) Source #

Wrap the callback into a GClosure.

mk_AsyncReadyCallback :: C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback) Source #

Generate a function pointer callable from C code, from a C_AsyncReadyCallback.

noAsyncReadyCallback :: Maybe AsyncReadyCallback Source #

A convenience synonym for Nothing :: Maybe AsyncReadyCallback.

noAsyncReadyCallback_WithClosures :: Maybe AsyncReadyCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe AsyncReadyCallback_WithClosures.

wrap_AsyncReadyCallback :: Maybe (Ptr (FunPtr C_AsyncReadyCallback)) -> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback Source #

Wrap a AsyncReadyCallback into a C_AsyncReadyCallback.

BusAcquiredCallback

type BusAcquiredCallback Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` to a message bus.
-> Text	`name`: The name that is requested to be owned.
-> IO ()

Invoked when a connection to a message bus has been obtained.

Since: 2.26

type BusAcquiredCallback_WithClosures Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` to a message bus.
-> Text	`name`: The name that is requested to be owned.
-> Ptr ()	`userData`: User data passed to `g_bus_own_name()`.
-> IO ()

Invoked when a connection to a message bus has been obtained.

Since: 2.26

type C_BusAcquiredCallback = Ptr DBusConnection -> CString -> Ptr () -> IO () Source #

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

drop_closures_BusAcquiredCallback :: BusAcquiredCallback -> BusAcquiredCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BusAcquiredCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_BusAcquiredCallback
-> a	`connection`: The `DBusConnection` to a message bus.
-> Text	`name`: The name that is requested to be owned.
-> Ptr ()	`userData`: User data passed to `g_bus_own_name()`.
-> m ()

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

genClosure_BusAcquiredCallback :: MonadIO m => BusAcquiredCallback -> m (GClosure C_BusAcquiredCallback) Source #

Wrap the callback into a GClosure.

mk_BusAcquiredCallback :: C_BusAcquiredCallback -> IO (FunPtr C_BusAcquiredCallback) Source #

Generate a function pointer callable from C code, from a C_BusAcquiredCallback.

noBusAcquiredCallback :: Maybe BusAcquiredCallback Source #

A convenience synonym for Nothing :: Maybe BusAcquiredCallback.

noBusAcquiredCallback_WithClosures :: Maybe BusAcquiredCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BusAcquiredCallback_WithClosures.

wrap_BusAcquiredCallback :: Maybe (Ptr (FunPtr C_BusAcquiredCallback)) -> BusAcquiredCallback_WithClosures -> C_BusAcquiredCallback Source #

Wrap a BusAcquiredCallback into a C_BusAcquiredCallback.

BusNameAcquiredCallback

type BusNameAcquiredCallback Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` on which to acquired the name.
-> Text	`name`: The name being owned.
-> IO ()

Invoked when the name is acquired.

Since: 2.26

type BusNameAcquiredCallback_WithClosures Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` on which to acquired the name.
-> Text	`name`: The name being owned.
-> Ptr ()	`userData`: User data passed to `g_bus_own_name()` or `g_bus_own_name_on_connection()`.
-> IO ()

Invoked when the name is acquired.

Since: 2.26

type C_BusNameAcquiredCallback = Ptr DBusConnection -> CString -> Ptr () -> IO () Source #

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

drop_closures_BusNameAcquiredCallback :: BusNameAcquiredCallback -> BusNameAcquiredCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BusNameAcquiredCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_BusNameAcquiredCallback
-> a	`connection`: The `DBusConnection` on which to acquired the name.
-> Text	`name`: The name being owned.
-> Ptr ()	`userData`: User data passed to `g_bus_own_name()` or `g_bus_own_name_on_connection()`.
-> m ()

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

genClosure_BusNameAcquiredCallback :: MonadIO m => BusNameAcquiredCallback -> m (GClosure C_BusNameAcquiredCallback) Source #

Wrap the callback into a GClosure.

mk_BusNameAcquiredCallback :: C_BusNameAcquiredCallback -> IO (FunPtr C_BusNameAcquiredCallback) Source #

Generate a function pointer callable from C code, from a C_BusNameAcquiredCallback.

noBusNameAcquiredCallback :: Maybe BusNameAcquiredCallback Source #

A convenience synonym for Nothing :: Maybe BusNameAcquiredCallback.

noBusNameAcquiredCallback_WithClosures :: Maybe BusNameAcquiredCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BusNameAcquiredCallback_WithClosures.

wrap_BusNameAcquiredCallback :: Maybe (Ptr (FunPtr C_BusNameAcquiredCallback)) -> BusNameAcquiredCallback_WithClosures -> C_BusNameAcquiredCallback Source #

Wrap a BusNameAcquiredCallback into a C_BusNameAcquiredCallback.

BusNameAppearedCallback

type BusNameAppearedCallback Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` the name is being watched on.
-> Text	`name`: The name being watched.
-> Text	`nameOwner`: Unique name of the owner of the name being watched.
-> IO ()

Invoked when the name being watched is known to have to have an owner.

Since: 2.26

type BusNameAppearedCallback_WithClosures Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` the name is being watched on.
-> Text	`name`: The name being watched.
-> Text	`nameOwner`: Unique name of the owner of the name being watched.
-> Ptr ()	`userData`: User data passed to `g_bus_watch_name()`.
-> IO ()

Invoked when the name being watched is known to have to have an owner.

Since: 2.26

type C_BusNameAppearedCallback = Ptr DBusConnection -> CString -> CString -> Ptr () -> IO () Source #

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

drop_closures_BusNameAppearedCallback :: BusNameAppearedCallback -> BusNameAppearedCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BusNameAppearedCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_BusNameAppearedCallback
-> a	`connection`: The `DBusConnection` the name is being watched on.
-> Text	`name`: The name being watched.
-> Text	`nameOwner`: Unique name of the owner of the name being watched.
-> Ptr ()	`userData`: User data passed to `g_bus_watch_name()`.
-> m ()

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

genClosure_BusNameAppearedCallback :: MonadIO m => BusNameAppearedCallback -> m (GClosure C_BusNameAppearedCallback) Source #

Wrap the callback into a GClosure.

mk_BusNameAppearedCallback :: C_BusNameAppearedCallback -> IO (FunPtr C_BusNameAppearedCallback) Source #

Generate a function pointer callable from C code, from a C_BusNameAppearedCallback.

noBusNameAppearedCallback :: Maybe BusNameAppearedCallback Source #

A convenience synonym for Nothing :: Maybe BusNameAppearedCallback.

noBusNameAppearedCallback_WithClosures :: Maybe BusNameAppearedCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BusNameAppearedCallback_WithClosures.

wrap_BusNameAppearedCallback :: Maybe (Ptr (FunPtr C_BusNameAppearedCallback)) -> BusNameAppearedCallback_WithClosures -> C_BusNameAppearedCallback Source #

Wrap a BusNameAppearedCallback into a C_BusNameAppearedCallback.

BusNameLostCallback

type BusNameLostCallback Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` on which to acquire the name or `Nothing` if the connection was disconnected.
-> Text	`name`: The name being owned.
-> IO ()

Invoked when the name is lost or connection has been closed.

Since: 2.26

type BusNameLostCallback_WithClosures Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` on which to acquire the name or `Nothing` if the connection was disconnected.
-> Text	`name`: The name being owned.
-> Ptr ()	`userData`: User data passed to `g_bus_own_name()` or `g_bus_own_name_on_connection()`.
-> IO ()

Invoked when the name is lost or connection has been closed.

Since: 2.26

type C_BusNameLostCallback = Ptr DBusConnection -> CString -> Ptr () -> IO () Source #

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

drop_closures_BusNameLostCallback :: BusNameLostCallback -> BusNameLostCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BusNameLostCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_BusNameLostCallback
-> a	`connection`: The `DBusConnection` on which to acquire the name or `Nothing` if the connection was disconnected.
-> Text	`name`: The name being owned.
-> Ptr ()	`userData`: User data passed to `g_bus_own_name()` or `g_bus_own_name_on_connection()`.
-> m ()

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

genClosure_BusNameLostCallback :: MonadIO m => BusNameLostCallback -> m (GClosure C_BusNameLostCallback) Source #

Wrap the callback into a GClosure.

mk_BusNameLostCallback :: C_BusNameLostCallback -> IO (FunPtr C_BusNameLostCallback) Source #

Generate a function pointer callable from C code, from a C_BusNameLostCallback.

noBusNameLostCallback :: Maybe BusNameLostCallback Source #

A convenience synonym for Nothing :: Maybe BusNameLostCallback.

noBusNameLostCallback_WithClosures :: Maybe BusNameLostCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BusNameLostCallback_WithClosures.

wrap_BusNameLostCallback :: Maybe (Ptr (FunPtr C_BusNameLostCallback)) -> BusNameLostCallback_WithClosures -> C_BusNameLostCallback Source #

Wrap a BusNameLostCallback into a C_BusNameLostCallback.

BusNameVanishedCallback

type BusNameVanishedCallback Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` the name is being watched on, or `Nothing`.
-> Text	`name`: The name being watched.
-> IO ()

Invoked when the name being watched is known not to have to have an owner.

This is also invoked when the DBusConnection on which the watch was established has been closed. In that case, connection will be Nothing.

Since: 2.26

type BusNameVanishedCallback_WithClosures Source #

Arguments

= DBusConnection	`connection`: The `DBusConnection` the name is being watched on, or `Nothing`.
-> Text	`name`: The name being watched.
-> Ptr ()	`userData`: User data passed to `g_bus_watch_name()`.
-> IO ()

Invoked when the name being watched is known not to have to have an owner.

This is also invoked when the DBusConnection on which the watch was established has been closed. In that case, connection will be Nothing.

Since: 2.26

type C_BusNameVanishedCallback = Ptr DBusConnection -> CString -> Ptr () -> IO () Source #

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

drop_closures_BusNameVanishedCallback :: BusNameVanishedCallback -> BusNameVanishedCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_BusNameVanishedCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_BusNameVanishedCallback
-> a	`connection`: The `DBusConnection` the name is being watched on, or `Nothing`.
-> Text	`name`: The name being watched.
-> Ptr ()	`userData`: User data passed to `g_bus_watch_name()`.
-> m ()

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

genClosure_BusNameVanishedCallback :: MonadIO m => BusNameVanishedCallback -> m (GClosure C_BusNameVanishedCallback) Source #

Wrap the callback into a GClosure.

mk_BusNameVanishedCallback :: C_BusNameVanishedCallback -> IO (FunPtr C_BusNameVanishedCallback) Source #

Generate a function pointer callable from C code, from a C_BusNameVanishedCallback.

noBusNameVanishedCallback :: Maybe BusNameVanishedCallback Source #

A convenience synonym for Nothing :: Maybe BusNameVanishedCallback.

noBusNameVanishedCallback_WithClosures :: Maybe BusNameVanishedCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe BusNameVanishedCallback_WithClosures.

wrap_BusNameVanishedCallback :: Maybe (Ptr (FunPtr C_BusNameVanishedCallback)) -> BusNameVanishedCallback_WithClosures -> C_BusNameVanishedCallback Source #

Wrap a BusNameVanishedCallback into a C_BusNameVanishedCallback.

CancellableSourceFunc

type C_CancellableSourceFunc = Ptr Cancellable -> Ptr () -> IO CInt Source #

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

type CancellableSourceFunc Source #

Arguments

= Maybe Cancellable	`cancellable`: the `Cancellable`
-> IO Bool	Returns: it should return `False` if the source should be removed.

This is the function type of the callback used for the Source returned by cancellableSourceNew.

Since: 2.28

type CancellableSourceFunc_WithClosures Source #

Arguments

= Maybe Cancellable	`cancellable`: the `Cancellable`
-> Ptr ()	`data`: data passed in by the user.
-> IO Bool	Returns: it should return `False` if the source should be removed.

This is the function type of the callback used for the Source returned by cancellableSourceNew.

Since: 2.28

drop_closures_CancellableSourceFunc :: CancellableSourceFunc -> CancellableSourceFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_CancellableSourceFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsCancellable a)
=> FunPtr C_CancellableSourceFunc
-> Maybe a	`cancellable`: the `Cancellable`
-> Ptr ()	`data`: data passed in by the user.
-> m Bool	Returns: it should return `False` if the source should be removed.

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

genClosure_CancellableSourceFunc :: MonadIO m => CancellableSourceFunc -> m (GClosure C_CancellableSourceFunc) Source #

Wrap the callback into a GClosure.

mk_CancellableSourceFunc :: C_CancellableSourceFunc -> IO (FunPtr C_CancellableSourceFunc) Source #

Generate a function pointer callable from C code, from a C_CancellableSourceFunc.

noCancellableSourceFunc :: Maybe CancellableSourceFunc Source #

A convenience synonym for Nothing :: Maybe CancellableSourceFunc.

noCancellableSourceFunc_WithClosures :: Maybe CancellableSourceFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe CancellableSourceFunc_WithClosures.

wrap_CancellableSourceFunc :: Maybe (Ptr (FunPtr C_CancellableSourceFunc)) -> CancellableSourceFunc_WithClosures -> C_CancellableSourceFunc Source #

Wrap a CancellableSourceFunc into a C_CancellableSourceFunc.

DBusInterfaceGetPropertyFunc

type C_DBusInterfaceGetPropertyFunc = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr GError -> Ptr () -> IO (Ptr GVariant) Source #

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

type DBusInterfaceGetPropertyFunc Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name for the property.
-> Text	`propertyName`: The name of the property to get the value of.
-> GError	`error`: Return location for error.
-> IO GVariant	Returns: A `GVariant` with the value for `propertyName` or `Nothing` if `error` is set. If the returned `GVariant` is floating, it is consumed - otherwise its reference count is decreased by one.

The type of the getProperty function in DBusInterfaceVTable.

Since: 2.26

type DBusInterfaceGetPropertyFunc_WithClosures Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name for the property.
-> Text	`propertyName`: The name of the property to get the value of.
-> GError	`error`: Return location for error.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `g_dbus_connection_register_object()`.
-> IO GVariant	Returns: A `GVariant` with the value for `propertyName` or `Nothing` if `error` is set. If the returned `GVariant` is floating, it is consumed - otherwise its reference count is decreased by one.

The type of the getProperty function in DBusInterfaceVTable.

Since: 2.26

drop_closures_DBusInterfaceGetPropertyFunc :: DBusInterfaceGetPropertyFunc -> DBusInterfaceGetPropertyFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusInterfaceGetPropertyFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_DBusInterfaceGetPropertyFunc
-> a	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name for the property.
-> Text	`propertyName`: The name of the property to get the value of.
-> GError	`error`: Return location for error.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `g_dbus_connection_register_object()`.
-> m GVariant	Returns: A `GVariant` with the value for `propertyName` or `Nothing` if `error` is set. If the returned `GVariant` is floating, it is consumed - otherwise its reference count is decreased by one.

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

genClosure_DBusInterfaceGetPropertyFunc :: MonadIO m => DBusInterfaceGetPropertyFunc -> m (GClosure C_DBusInterfaceGetPropertyFunc) Source #

Wrap the callback into a GClosure.

mk_DBusInterfaceGetPropertyFunc :: C_DBusInterfaceGetPropertyFunc -> IO (FunPtr C_DBusInterfaceGetPropertyFunc) Source #

Generate a function pointer callable from C code, from a C_DBusInterfaceGetPropertyFunc.

noDBusInterfaceGetPropertyFunc :: Maybe DBusInterfaceGetPropertyFunc Source #

A convenience synonym for Nothing :: Maybe DBusInterfaceGetPropertyFunc.

noDBusInterfaceGetPropertyFunc_WithClosures :: Maybe DBusInterfaceGetPropertyFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusInterfaceGetPropertyFunc_WithClosures.

wrap_DBusInterfaceGetPropertyFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceGetPropertyFunc)) -> DBusInterfaceGetPropertyFunc_WithClosures -> C_DBusInterfaceGetPropertyFunc Source #

Wrap a DBusInterfaceGetPropertyFunc into a C_DBusInterfaceGetPropertyFunc.

DBusInterfaceMethodCallFunc

type C_DBusInterfaceMethodCallFunc = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr GVariant -> Ptr DBusMethodInvocation -> Ptr () -> IO () Source #

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

type DBusInterfaceMethodCallFunc Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name the method was invoked on.
-> Text	`methodName`: The name of the method that was invoked.
-> GVariant	`parameters`: A `GVariant` tuple with parameters.
-> DBusMethodInvocation	`invocation`: A `DBusMethodInvocation` object that must be used to return a value or error.
-> IO ()

The type of the methodCall function in DBusInterfaceVTable.

Since: 2.26

type DBusInterfaceMethodCallFunc_WithClosures Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name the method was invoked on.
-> Text	`methodName`: The name of the method that was invoked.
-> GVariant	`parameters`: A `GVariant` tuple with parameters.
-> DBusMethodInvocation	`invocation`: A `DBusMethodInvocation` object that must be used to return a value or error.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `g_dbus_connection_register_object()`.
-> IO ()

The type of the methodCall function in DBusInterfaceVTable.

Since: 2.26

drop_closures_DBusInterfaceMethodCallFunc :: DBusInterfaceMethodCallFunc -> DBusInterfaceMethodCallFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusInterfaceMethodCallFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a, IsDBusMethodInvocation b)
=> FunPtr C_DBusInterfaceMethodCallFunc
-> a	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name the method was invoked on.
-> Text	`methodName`: The name of the method that was invoked.
-> GVariant	`parameters`: A `GVariant` tuple with parameters.
-> b	`invocation`: A `DBusMethodInvocation` object that must be used to return a value or error.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `g_dbus_connection_register_object()`.
-> m ()

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

genClosure_DBusInterfaceMethodCallFunc :: MonadIO m => DBusInterfaceMethodCallFunc -> m (GClosure C_DBusInterfaceMethodCallFunc) Source #

Wrap the callback into a GClosure.

mk_DBusInterfaceMethodCallFunc :: C_DBusInterfaceMethodCallFunc -> IO (FunPtr C_DBusInterfaceMethodCallFunc) Source #

Generate a function pointer callable from C code, from a C_DBusInterfaceMethodCallFunc.

noDBusInterfaceMethodCallFunc :: Maybe DBusInterfaceMethodCallFunc Source #

A convenience synonym for Nothing :: Maybe DBusInterfaceMethodCallFunc.

noDBusInterfaceMethodCallFunc_WithClosures :: Maybe DBusInterfaceMethodCallFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusInterfaceMethodCallFunc_WithClosures.

wrap_DBusInterfaceMethodCallFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceMethodCallFunc)) -> DBusInterfaceMethodCallFunc_WithClosures -> C_DBusInterfaceMethodCallFunc Source #

Wrap a DBusInterfaceMethodCallFunc into a C_DBusInterfaceMethodCallFunc.

DBusInterfaceSetPropertyFunc

type C_DBusInterfaceSetPropertyFunc = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr GVariant -> Ptr GError -> Ptr () -> IO CInt Source #

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

type DBusInterfaceSetPropertyFunc Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name for the property.
-> Text	`propertyName`: The name of the property to get the value of.
-> GVariant	`value`: The value to set the property to.
-> GError	`error`: Return location for error.
-> IO Bool	Returns: `True` if the property was set to `value`, `False` if `error` is set.

The type of the setProperty function in DBusInterfaceVTable.

Since: 2.26

type DBusInterfaceSetPropertyFunc_WithClosures Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name for the property.
-> Text	`propertyName`: The name of the property to get the value of.
-> GVariant	`value`: The value to set the property to.
-> GError	`error`: Return location for error.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `g_dbus_connection_register_object()`.
-> IO Bool	Returns: `True` if the property was set to `value`, `False` if `error` is set.

The type of the setProperty function in DBusInterfaceVTable.

Since: 2.26

drop_closures_DBusInterfaceSetPropertyFunc :: DBusInterfaceSetPropertyFunc -> DBusInterfaceSetPropertyFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusInterfaceSetPropertyFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_DBusInterfaceSetPropertyFunc
-> a	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that the method was invoked on.
-> Text	`interfaceName`: The D-Bus interface name for the property.
-> Text	`propertyName`: The name of the property to get the value of.
-> GVariant	`value`: The value to set the property to.
-> GError	`error`: Return location for error.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `g_dbus_connection_register_object()`.
-> m Bool	Returns: `True` if the property was set to `value`, `False` if `error` is set.

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

genClosure_DBusInterfaceSetPropertyFunc :: MonadIO m => DBusInterfaceSetPropertyFunc -> m (GClosure C_DBusInterfaceSetPropertyFunc) Source #

Wrap the callback into a GClosure.

mk_DBusInterfaceSetPropertyFunc :: C_DBusInterfaceSetPropertyFunc -> IO (FunPtr C_DBusInterfaceSetPropertyFunc) Source #

Generate a function pointer callable from C code, from a C_DBusInterfaceSetPropertyFunc.

noDBusInterfaceSetPropertyFunc :: Maybe DBusInterfaceSetPropertyFunc Source #

A convenience synonym for Nothing :: Maybe DBusInterfaceSetPropertyFunc.

noDBusInterfaceSetPropertyFunc_WithClosures :: Maybe DBusInterfaceSetPropertyFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusInterfaceSetPropertyFunc_WithClosures.

wrap_DBusInterfaceSetPropertyFunc :: Maybe (Ptr (FunPtr C_DBusInterfaceSetPropertyFunc)) -> DBusInterfaceSetPropertyFunc_WithClosures -> C_DBusInterfaceSetPropertyFunc Source #

Wrap a DBusInterfaceSetPropertyFunc into a C_DBusInterfaceSetPropertyFunc.

DBusMessageFilterFunction

type C_DBusMessageFilterFunction = Ptr DBusConnection -> Ptr DBusMessage -> CInt -> Ptr () -> IO (Ptr DBusMessage) Source #

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

type DBusMessageFilterFunction Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> DBusMessage	`message`: A locked `DBusMessage` that the filter function takes ownership of.
-> Bool	`incoming`: `True` if it is a message received from the other peer, `False` if it is a message to be sent to the other peer.
-> IO (Maybe DBusMessage)	Returns: A `DBusMessage` that will be freed with `objectUnref` or `Nothing` to drop the message. Passive filter functions can simply return the passed `message` object.

Signature for function used in dBusConnectionAddFilter.

A filter function is passed a DBusMessage and expected to return a DBusMessage too. Passive filter functions that don't modify the message can simply return the message object: > >static GDBusMessage * >passive_filter (GDBusConnection *connection > GDBusMessage *message, > gboolean incoming, > gpointer user_data) >{ > // inspect @message > return message; >}

Filter functions that wants to drop a message can simply return Nothing: > >static GDBusMessage * >drop_filter (GDBusConnection *connection > GDBusMessage *message, > gboolean incoming, > gpointer user_data) >{ > if (should_drop_message) > { > g_object_unref (message); > message = NULL; > } > return message; >}

Finally, a filter function may modify a message by copying it: > >static GDBusMessage * >modifying_filter (GDBusConnection *connection > GDBusMessage *message, > gboolean incoming, > gpointer user_data) >{ > GDBusMessage *copy; > GError *error; > > error = NULL; > copy = g_dbus_message_copy (message, &error); > // handle error being set > g_object_unref (message); > > // modifycopy > > return copy; >}

If the returned DBusMessage is different from message and cannot be sent on connection (it could use features, such as file descriptors, not compatible with connection), then a warning is logged to standard error. Applications can check this ahead of time using dBusMessageToBlob passing a DBusCapabilityFlags value obtained from connection.

Since: 2.26

type DBusMessageFilterFunction_WithClosures Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> DBusMessage	`message`: A locked `DBusMessage` that the filter function takes ownership of.
-> Bool	`incoming`: `True` if it is a message received from the other peer, `False` if it is a message to be sent to the other peer.
-> Ptr ()	`userData`: User data passed when adding the filter.
-> IO (Maybe DBusMessage)	Returns: A `DBusMessage` that will be freed with `objectUnref` or `Nothing` to drop the message. Passive filter functions can simply return the passed `message` object.

Signature for function used in dBusConnectionAddFilter.

A filter function is passed a DBusMessage and expected to return a DBusMessage too. Passive filter functions that don't modify the message can simply return the message object: > >static GDBusMessage * >passive_filter (GDBusConnection *connection > GDBusMessage *message, > gboolean incoming, > gpointer user_data) >{ > // inspect @message > return message; >}

Filter functions that wants to drop a message can simply return Nothing: > >static GDBusMessage * >drop_filter (GDBusConnection *connection > GDBusMessage *message, > gboolean incoming, > gpointer user_data) >{ > if (should_drop_message) > { > g_object_unref (message); > message = NULL; > } > return message; >}

Finally, a filter function may modify a message by copying it: > >static GDBusMessage * >modifying_filter (GDBusConnection *connection > GDBusMessage *message, > gboolean incoming, > gpointer user_data) >{ > GDBusMessage *copy; > GError *error; > > error = NULL; > copy = g_dbus_message_copy (message, &error); > // handle error being set > g_object_unref (message); > > // modifycopy > > return copy; >}

If the returned DBusMessage is different from message and cannot be sent on connection (it could use features, such as file descriptors, not compatible with connection), then a warning is logged to standard error. Applications can check this ahead of time using dBusMessageToBlob passing a DBusCapabilityFlags value obtained from connection.

Since: 2.26

drop_closures_DBusMessageFilterFunction :: DBusMessageFilterFunction -> DBusMessageFilterFunction_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusMessageFilterFunction Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a, IsDBusMessage b)
=> FunPtr C_DBusMessageFilterFunction
-> a	`connection`: A `DBusConnection`.
-> b	`message`: A locked `DBusMessage` that the filter function takes ownership of.
-> Bool	`incoming`: `True` if it is a message received from the other peer, `False` if it is a message to be sent to the other peer.
-> Ptr ()	`userData`: User data passed when adding the filter.
-> m (Maybe DBusMessage)	Returns: A `DBusMessage` that will be freed with `objectUnref` or `Nothing` to drop the message. Passive filter functions can simply return the passed `message` object.

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

genClosure_DBusMessageFilterFunction :: MonadIO m => DBusMessageFilterFunction -> m (GClosure C_DBusMessageFilterFunction) Source #

Wrap the callback into a GClosure.

mk_DBusMessageFilterFunction :: C_DBusMessageFilterFunction -> IO (FunPtr C_DBusMessageFilterFunction) Source #

Generate a function pointer callable from C code, from a C_DBusMessageFilterFunction.

noDBusMessageFilterFunction :: Maybe DBusMessageFilterFunction Source #

A convenience synonym for Nothing :: Maybe DBusMessageFilterFunction.

noDBusMessageFilterFunction_WithClosures :: Maybe DBusMessageFilterFunction_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusMessageFilterFunction_WithClosures.

wrap_DBusMessageFilterFunction :: Maybe (Ptr (FunPtr C_DBusMessageFilterFunction)) -> DBusMessageFilterFunction_WithClosures -> C_DBusMessageFilterFunction Source #

Wrap a DBusMessageFilterFunction into a C_DBusMessageFilterFunction.

DBusProxyTypeFunc

type C_DBusProxyTypeFunc = Ptr DBusObjectManagerClient -> CString -> CString -> Ptr () -> IO CGType Source #

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

type DBusProxyTypeFunc Source #

Arguments

= DBusObjectManagerClient	`manager`: A `DBusObjectManagerClient`.
-> Text	`objectPath`: The object path of the remote object.
-> Maybe Text	`interfaceName`: The interface name of the remote object or `Nothing` if a `DBusObjectProxy` `GType` is requested.
-> IO GType	Returns: A `GType` to use for the remote object. The returned type must be a `DBusProxy` or `DBusObjectProxy` -derived type.

Function signature for a function used to determine the GType to use for an interface proxy (if interfaceName is not Nothing) or object proxy (if interfaceName is Nothing).

This function is called in the [thread-default main loop][g-main-context-push-thread-default] that manager was constructed in.

Since: 2.30

type DBusProxyTypeFunc_WithClosures Source #

Arguments

= DBusObjectManagerClient	`manager`: A `DBusObjectManagerClient`.
-> Text	`objectPath`: The object path of the remote object.
-> Maybe Text	`interfaceName`: The interface name of the remote object or `Nothing` if a `DBusObjectProxy` `GType` is requested.
-> Ptr ()	`data`: data passed in by the user.
-> IO GType	Returns: A `GType` to use for the remote object. The returned type must be a `DBusProxy` or `DBusObjectProxy` -derived type.

Function signature for a function used to determine the GType to use for an interface proxy (if interfaceName is not Nothing) or object proxy (if interfaceName is Nothing).

This function is called in the [thread-default main loop][g-main-context-push-thread-default] that manager was constructed in.

Since: 2.30

drop_closures_DBusProxyTypeFunc :: DBusProxyTypeFunc -> DBusProxyTypeFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusProxyTypeFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusObjectManagerClient a)
=> FunPtr C_DBusProxyTypeFunc
-> a	`manager`: A `DBusObjectManagerClient`.
-> Text	`objectPath`: The object path of the remote object.
-> Maybe Text	`interfaceName`: The interface name of the remote object or `Nothing` if a `DBusObjectProxy` `GType` is requested.
-> Ptr ()	`data`: data passed in by the user.
-> m GType	Returns: A `GType` to use for the remote object. The returned type must be a `DBusProxy` or `DBusObjectProxy` -derived type.

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

genClosure_DBusProxyTypeFunc :: MonadIO m => DBusProxyTypeFunc -> m (GClosure C_DBusProxyTypeFunc) Source #

Wrap the callback into a GClosure.

mk_DBusProxyTypeFunc :: C_DBusProxyTypeFunc -> IO (FunPtr C_DBusProxyTypeFunc) Source #

Generate a function pointer callable from C code, from a C_DBusProxyTypeFunc.

noDBusProxyTypeFunc :: Maybe DBusProxyTypeFunc Source #

A convenience synonym for Nothing :: Maybe DBusProxyTypeFunc.

noDBusProxyTypeFunc_WithClosures :: Maybe DBusProxyTypeFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusProxyTypeFunc_WithClosures.

wrap_DBusProxyTypeFunc :: Maybe (Ptr (FunPtr C_DBusProxyTypeFunc)) -> DBusProxyTypeFunc_WithClosures -> C_DBusProxyTypeFunc Source #

Wrap a DBusProxyTypeFunc into a C_DBusProxyTypeFunc.

DBusSignalCallback

type C_DBusSignalCallback = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr GVariant -> Ptr () -> IO () Source #

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

type DBusSignalCallback Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Maybe Text	`senderName`: The unique bus name of the sender of the signal, or `Nothing` on a peer-to-peer D-Bus connection.
-> Text	`objectPath`: The object path that the signal was emitted on.
-> Text	`interfaceName`: The name of the interface.
-> Text	`signalName`: The name of the signal.
-> GVariant	`parameters`: A `GVariant` tuple with parameters for the signal.
-> IO ()

Signature for callback function used in dBusConnectionSignalSubscribe.

Since: 2.26

type DBusSignalCallback_WithClosures Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Maybe Text	`senderName`: The unique bus name of the sender of the signal, or `Nothing` on a peer-to-peer D-Bus connection.
-> Text	`objectPath`: The object path that the signal was emitted on.
-> Text	`interfaceName`: The name of the interface.
-> Text	`signalName`: The name of the signal.
-> GVariant	`parameters`: A `GVariant` tuple with parameters for the signal.
-> Ptr ()	`userData`: User data passed when subscribing to the signal.
-> IO ()

Signature for callback function used in dBusConnectionSignalSubscribe.

Since: 2.26

drop_closures_DBusSignalCallback :: DBusSignalCallback -> DBusSignalCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusSignalCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_DBusSignalCallback
-> a	`connection`: A `DBusConnection`.
-> Maybe Text	`senderName`: The unique bus name of the sender of the signal, or `Nothing` on a peer-to-peer D-Bus connection.
-> Text	`objectPath`: The object path that the signal was emitted on.
-> Text	`interfaceName`: The name of the interface.
-> Text	`signalName`: The name of the signal.
-> GVariant	`parameters`: A `GVariant` tuple with parameters for the signal.
-> Ptr ()	`userData`: User data passed when subscribing to the signal.
-> m ()

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

genClosure_DBusSignalCallback :: MonadIO m => DBusSignalCallback -> m (GClosure C_DBusSignalCallback) Source #

Wrap the callback into a GClosure.

mk_DBusSignalCallback :: C_DBusSignalCallback -> IO (FunPtr C_DBusSignalCallback) Source #

Generate a function pointer callable from C code, from a C_DBusSignalCallback.

noDBusSignalCallback :: Maybe DBusSignalCallback Source #

A convenience synonym for Nothing :: Maybe DBusSignalCallback.

noDBusSignalCallback_WithClosures :: Maybe DBusSignalCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusSignalCallback_WithClosures.

wrap_DBusSignalCallback :: Maybe (Ptr (FunPtr C_DBusSignalCallback)) -> DBusSignalCallback_WithClosures -> C_DBusSignalCallback Source #

Wrap a DBusSignalCallback into a C_DBusSignalCallback.

DBusSubtreeDispatchFunc

type C_DBusSubtreeDispatchFunc = Ptr DBusConnection -> CString -> CString -> CString -> CString -> Ptr () -> Ptr () -> IO (Ptr DBusInterfaceVTable) Source #

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

type DBusSubtreeDispatchFunc Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> Text	`interfaceName`: The D-Bus interface name that the method call or property access is for.
-> Text	`node`: A node that is a child of `objectPath` (relative to `objectPath`) or `Nothing` for the root of the subtree.
-> Ptr ()	`outUserData`: Return location for user data to pass to functions in the returned `DBusInterfaceVTable`.
-> IO (Maybe DBusInterfaceVTable)	Returns: A `DBusInterfaceVTable` or `Nothing` if you don't want to handle the methods.

The type of the dispatch function in DBusSubtreeVTable.

Subtrees are flat. node, if non-Nothing, is always exactly one segment of the object path (ie: it never contains a slash).

Since: 2.26

type DBusSubtreeDispatchFunc_WithClosures Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> Text	`interfaceName`: The D-Bus interface name that the method call or property access is for.
-> Text	`node`: A node that is a child of `objectPath` (relative to `objectPath`) or `Nothing` for the root of the subtree.
-> Ptr ()	`outUserData`: Return location for user data to pass to functions in the returned `DBusInterfaceVTable`.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `dBusConnectionRegisterSubtree`.
-> IO (Maybe DBusInterfaceVTable)	Returns: A `DBusInterfaceVTable` or `Nothing` if you don't want to handle the methods.

The type of the dispatch function in DBusSubtreeVTable.

Subtrees are flat. node, if non-Nothing, is always exactly one segment of the object path (ie: it never contains a slash).

Since: 2.26

drop_closures_DBusSubtreeDispatchFunc :: DBusSubtreeDispatchFunc -> DBusSubtreeDispatchFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusSubtreeDispatchFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_DBusSubtreeDispatchFunc
-> a	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> Text	`interfaceName`: The D-Bus interface name that the method call or property access is for.
-> Text	`node`: A node that is a child of `objectPath` (relative to `objectPath`) or `Nothing` for the root of the subtree.
-> Ptr ()	`outUserData`: Return location for user data to pass to functions in the returned `DBusInterfaceVTable`.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `dBusConnectionRegisterSubtree`.
-> m (Maybe DBusInterfaceVTable)	Returns: A `DBusInterfaceVTable` or `Nothing` if you don't want to handle the methods.

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

genClosure_DBusSubtreeDispatchFunc :: MonadIO m => DBusSubtreeDispatchFunc -> m (GClosure C_DBusSubtreeDispatchFunc) Source #

Wrap the callback into a GClosure.

mk_DBusSubtreeDispatchFunc :: C_DBusSubtreeDispatchFunc -> IO (FunPtr C_DBusSubtreeDispatchFunc) Source #

Generate a function pointer callable from C code, from a C_DBusSubtreeDispatchFunc.

noDBusSubtreeDispatchFunc :: Maybe DBusSubtreeDispatchFunc Source #

A convenience synonym for Nothing :: Maybe DBusSubtreeDispatchFunc.

noDBusSubtreeDispatchFunc_WithClosures :: Maybe DBusSubtreeDispatchFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusSubtreeDispatchFunc_WithClosures.

wrap_DBusSubtreeDispatchFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeDispatchFunc)) -> DBusSubtreeDispatchFunc_WithClosures -> C_DBusSubtreeDispatchFunc Source #

Wrap a DBusSubtreeDispatchFunc into a C_DBusSubtreeDispatchFunc.

DBusSubtreeEnumerateFunc

type C_DBusSubtreeEnumerateFunc = Ptr DBusConnection -> CString -> CString -> Ptr () -> IO (Ptr CString) Source #

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

type DBusSubtreeEnumerateFunc Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> IO [Text]	Returns: A newly allocated array of strings for node names that are children of `objectPath`.

The type of the enumerate function in DBusSubtreeVTable.

This function is called when generating introspection data and also when preparing to dispatch incoming messages in the event that the DBusSubtreeFlagsDispatchToUnenumeratedNodes flag is not specified (ie: to verify that the object path is valid).

Hierarchies are not supported; the items that you return should not contain the / character.

The return value will be freed with strfreev.

Since: 2.26

type DBusSubtreeEnumerateFunc_WithClosures Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `dBusConnectionRegisterSubtree`.
-> IO [Text]	Returns: A newly allocated array of strings for node names that are children of `objectPath`.

The type of the enumerate function in DBusSubtreeVTable.

This function is called when generating introspection data and also when preparing to dispatch incoming messages in the event that the DBusSubtreeFlagsDispatchToUnenumeratedNodes flag is not specified (ie: to verify that the object path is valid).

Hierarchies are not supported; the items that you return should not contain the / character.

The return value will be freed with strfreev.

Since: 2.26

drop_closures_DBusSubtreeEnumerateFunc :: DBusSubtreeEnumerateFunc -> DBusSubtreeEnumerateFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusSubtreeEnumerateFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_DBusSubtreeEnumerateFunc
-> a	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `dBusConnectionRegisterSubtree`.
-> m [Text]	Returns: A newly allocated array of strings for node names that are children of `objectPath`.

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

genClosure_DBusSubtreeEnumerateFunc :: MonadIO m => DBusSubtreeEnumerateFunc -> m (GClosure C_DBusSubtreeEnumerateFunc) Source #

Wrap the callback into a GClosure.

mk_DBusSubtreeEnumerateFunc :: C_DBusSubtreeEnumerateFunc -> IO (FunPtr C_DBusSubtreeEnumerateFunc) Source #

Generate a function pointer callable from C code, from a C_DBusSubtreeEnumerateFunc.

noDBusSubtreeEnumerateFunc :: Maybe DBusSubtreeEnumerateFunc Source #

A convenience synonym for Nothing :: Maybe DBusSubtreeEnumerateFunc.

noDBusSubtreeEnumerateFunc_WithClosures :: Maybe DBusSubtreeEnumerateFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusSubtreeEnumerateFunc_WithClosures.

wrap_DBusSubtreeEnumerateFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeEnumerateFunc)) -> DBusSubtreeEnumerateFunc_WithClosures -> C_DBusSubtreeEnumerateFunc Source #

Wrap a DBusSubtreeEnumerateFunc into a C_DBusSubtreeEnumerateFunc.

DBusSubtreeIntrospectFunc

type C_DBusSubtreeIntrospectFunc = Ptr DBusConnection -> CString -> CString -> CString -> Ptr () -> IO (Ptr (Ptr DBusInterfaceInfo)) Source #

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

type DBusSubtreeIntrospectFunc Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> Text	`node`: A node that is a child of `objectPath` (relative to `objectPath`) or `Nothing` for the root of the subtree.
-> IO (Maybe [DBusInterfaceInfo])	Returns: A `Nothing`-terminated array of pointers to `DBusInterfaceInfo`, or `Nothing`.

The type of the introspect function in DBusSubtreeVTable.

Subtrees are flat. node, if non-Nothing, is always exactly one segment of the object path (ie: it never contains a slash).

This function should return Nothing to indicate that there is no object at this node.

If this function returns non-Nothing, the return value is expected to be a Nothing-terminated array of pointers to DBusInterfaceInfo structures describing the interfaces implemented by node. This array will have dBusInterfaceInfoUnref called on each item before being freed with free.

The difference between returning Nothing and an array containing zero items is that the standard DBus interfaces will returned to the remote introspector in the empty array case, but not in the Nothing case.

Since: 2.26

type DBusSubtreeIntrospectFunc_WithClosures Source #

Arguments

= DBusConnection	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> Text	`node`: A node that is a child of `objectPath` (relative to `objectPath`) or `Nothing` for the root of the subtree.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `dBusConnectionRegisterSubtree`.
-> IO (Maybe [DBusInterfaceInfo])	Returns: A `Nothing`-terminated array of pointers to `DBusInterfaceInfo`, or `Nothing`.

The type of the introspect function in DBusSubtreeVTable.

Subtrees are flat. node, if non-Nothing, is always exactly one segment of the object path (ie: it never contains a slash).

This function should return Nothing to indicate that there is no object at this node.

If this function returns non-Nothing, the return value is expected to be a Nothing-terminated array of pointers to DBusInterfaceInfo structures describing the interfaces implemented by node. This array will have dBusInterfaceInfoUnref called on each item before being freed with free.

The difference between returning Nothing and an array containing zero items is that the standard DBus interfaces will returned to the remote introspector in the empty array case, but not in the Nothing case.

Since: 2.26

drop_closures_DBusSubtreeIntrospectFunc :: DBusSubtreeIntrospectFunc -> DBusSubtreeIntrospectFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DBusSubtreeIntrospectFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)
=> FunPtr C_DBusSubtreeIntrospectFunc
-> a	`connection`: A `DBusConnection`.
-> Text	`sender`: The unique bus name of the remote caller.
-> Text	`objectPath`: The object path that was registered with `dBusConnectionRegisterSubtree`.
-> Text	`node`: A node that is a child of `objectPath` (relative to `objectPath`) or `Nothing` for the root of the subtree.
-> Ptr ()	`userData`: The `userData` `gpointer` passed to `dBusConnectionRegisterSubtree`.
-> m (Maybe [DBusInterfaceInfo])	Returns: A `Nothing`-terminated array of pointers to `DBusInterfaceInfo`, or `Nothing`.

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

genClosure_DBusSubtreeIntrospectFunc :: MonadIO m => DBusSubtreeIntrospectFunc -> m (GClosure C_DBusSubtreeIntrospectFunc) Source #

Wrap the callback into a GClosure.

mk_DBusSubtreeIntrospectFunc :: C_DBusSubtreeIntrospectFunc -> IO (FunPtr C_DBusSubtreeIntrospectFunc) Source #

Generate a function pointer callable from C code, from a C_DBusSubtreeIntrospectFunc.

noDBusSubtreeIntrospectFunc :: Maybe DBusSubtreeIntrospectFunc Source #

A convenience synonym for Nothing :: Maybe DBusSubtreeIntrospectFunc.

noDBusSubtreeIntrospectFunc_WithClosures :: Maybe DBusSubtreeIntrospectFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DBusSubtreeIntrospectFunc_WithClosures.

wrap_DBusSubtreeIntrospectFunc :: Maybe (Ptr (FunPtr C_DBusSubtreeIntrospectFunc)) -> DBusSubtreeIntrospectFunc_WithClosures -> C_DBusSubtreeIntrospectFunc Source #

Wrap a DBusSubtreeIntrospectFunc into a C_DBusSubtreeIntrospectFunc.

DatagramBasedSourceFunc

type C_DatagramBasedSourceFunc = Ptr DatagramBased -> CUInt -> Ptr () -> IO CInt Source #

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

type DatagramBasedSourceFunc Source #

Arguments

= DatagramBased	`datagramBased`: the `DatagramBased`
-> [IOCondition]	`condition`: the current condition at the source fired
-> IO Bool	Returns: `SOURCE_REMOVE` if the source should be removed, `SOURCE_CONTINUE` otherwise

This is the function type of the callback used for the Source returned by datagramBasedCreateSource.

Since: 2.48

type DatagramBasedSourceFunc_WithClosures Source #

Arguments

= DatagramBased	`datagramBased`: the `DatagramBased`
-> [IOCondition]	`condition`: the current condition at the source fired
-> Ptr ()	`data`: data passed in by the user
-> IO Bool	Returns: `SOURCE_REMOVE` if the source should be removed, `SOURCE_CONTINUE` otherwise

This is the function type of the callback used for the Source returned by datagramBasedCreateSource.

Since: 2.48

drop_closures_DatagramBasedSourceFunc :: DatagramBasedSourceFunc -> DatagramBasedSourceFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DatagramBasedSourceFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsDatagramBased a)
=> FunPtr C_DatagramBasedSourceFunc
-> a	`datagramBased`: the `DatagramBased`
-> [IOCondition]	`condition`: the current condition at the source fired
-> Ptr ()	`data`: data passed in by the user
-> m Bool	Returns: `SOURCE_REMOVE` if the source should be removed, `SOURCE_CONTINUE` otherwise

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

genClosure_DatagramBasedSourceFunc :: MonadIO m => DatagramBasedSourceFunc -> m (GClosure C_DatagramBasedSourceFunc) Source #

Wrap the callback into a GClosure.

mk_DatagramBasedSourceFunc :: C_DatagramBasedSourceFunc -> IO (FunPtr C_DatagramBasedSourceFunc) Source #

Generate a function pointer callable from C code, from a C_DatagramBasedSourceFunc.

noDatagramBasedSourceFunc :: Maybe DatagramBasedSourceFunc Source #

A convenience synonym for Nothing :: Maybe DatagramBasedSourceFunc.

noDatagramBasedSourceFunc_WithClosures :: Maybe DatagramBasedSourceFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe DatagramBasedSourceFunc_WithClosures.

wrap_DatagramBasedSourceFunc :: Maybe (Ptr (FunPtr C_DatagramBasedSourceFunc)) -> DatagramBasedSourceFunc_WithClosures -> C_DatagramBasedSourceFunc Source #

Wrap a DatagramBasedSourceFunc into a C_DatagramBasedSourceFunc.

DesktopAppLaunchCallback

type C_DesktopAppLaunchCallback = Ptr DesktopAppInfo -> Int32 -> Ptr () -> IO () Source #

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

type DesktopAppLaunchCallback Source #

Arguments

= DesktopAppInfo	`appinfo`: a `DesktopAppInfo`
-> Int32	`pid`: Process identifier
-> IO ()

During invocation, desktopAppInfoLaunchUrisAsManager may create one or more child processes. This callback is invoked once for each, providing the process ID.

type DesktopAppLaunchCallback_WithClosures Source #

Arguments

= DesktopAppInfo	`appinfo`: a `DesktopAppInfo`
-> Int32	`pid`: Process identifier
-> Ptr ()	`userData`: User data
-> IO ()

During invocation, desktopAppInfoLaunchUrisAsManager may create one or more child processes. This callback is invoked once for each, providing the process ID.

drop_closures_DesktopAppLaunchCallback :: DesktopAppLaunchCallback -> DesktopAppLaunchCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_DesktopAppLaunchCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsDesktopAppInfo a)
=> FunPtr C_DesktopAppLaunchCallback
-> a	`appinfo`: a `DesktopAppInfo`
-> Int32	`pid`: Process identifier
-> Ptr ()	`userData`: User data
-> m ()

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

genClosure_DesktopAppLaunchCallback :: MonadIO m => DesktopAppLaunchCallback -> m (GClosure C_DesktopAppLaunchCallback) Source #

Wrap the callback into a GClosure.

mk_DesktopAppLaunchCallback :: C_DesktopAppLaunchCallback -> IO (FunPtr C_DesktopAppLaunchCallback) Source #

Generate a function pointer callable from C code, from a C_DesktopAppLaunchCallback.

noDesktopAppLaunchCallback :: Maybe DesktopAppLaunchCallback Source #

A convenience synonym for Nothing :: Maybe DesktopAppLaunchCallback.

noDesktopAppLaunchCallback_WithClosures :: Maybe DesktopAppLaunchCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe DesktopAppLaunchCallback_WithClosures.

wrap_DesktopAppLaunchCallback :: Maybe (Ptr (FunPtr C_DesktopAppLaunchCallback)) -> DesktopAppLaunchCallback_WithClosures -> C_DesktopAppLaunchCallback Source #

Wrap a DesktopAppLaunchCallback into a C_DesktopAppLaunchCallback.

FileMeasureProgressCallback

type C_FileMeasureProgressCallback = CInt -> Word64 -> Word64 -> Word64 -> Ptr () -> IO () Source #

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

type FileMeasureProgressCallback Source #

Arguments

= Bool	`reporting`: `True` if more reports will come
-> Word64	`currentSize`: the current cumulative size measurement
-> Word64	`numDirs`: the number of directories visited so far
-> Word64	`numFiles`: the number of non-directory files encountered
-> IO ()

This callback type is used by fileMeasureDiskUsage to make periodic progress reports when measuring the amount of disk spaced used by a directory.

These calls are made on a best-effort basis and not all types of File will support them. At the minimum, however, one call will always be made immediately.

In the case that there is no support, reporting will be set to False (and the other values undefined) and no further calls will be made. Otherwise, the reporting will be True and the other values all-zeros during the first (immediate) call. In this way, you can know which type of progress UI to show without a delay.

For fileMeasureDiskUsage the callback is made directly. For g_file_measure_disk_usage_async() the callback is made via the default main context of the calling thread (ie: the same way that the final async result would be reported).

currentSize is in the same units as requested by the operation (see FileMeasureFlagsApparentSize).

The frequency of the updates is implementation defined, but is ideally about once every 200ms.

The last progress callback may or may not be equal to the final result. Always check the async result to get the final value.

Since: 2.38

type FileMeasureProgressCallback_WithClosures Source #

Arguments

= Bool	`reporting`: `True` if more reports will come
-> Word64	`currentSize`: the current cumulative size measurement
-> Word64	`numDirs`: the number of directories visited so far
-> Word64	`numFiles`: the number of non-directory files encountered
-> Ptr ()	`data`: the data passed to the original request for this callback
-> IO ()

This callback type is used by fileMeasureDiskUsage to make periodic progress reports when measuring the amount of disk spaced used by a directory.

These calls are made on a best-effort basis and not all types of File will support them. At the minimum, however, one call will always be made immediately.

In the case that there is no support, reporting will be set to False (and the other values undefined) and no further calls will be made. Otherwise, the reporting will be True and the other values all-zeros during the first (immediate) call. In this way, you can know which type of progress UI to show without a delay.

For fileMeasureDiskUsage the callback is made directly. For g_file_measure_disk_usage_async() the callback is made via the default main context of the calling thread (ie: the same way that the final async result would be reported).

currentSize is in the same units as requested by the operation (see FileMeasureFlagsApparentSize).

The frequency of the updates is implementation defined, but is ideally about once every 200ms.

The last progress callback may or may not be equal to the final result. Always check the async result to get the final value.

Since: 2.38

drop_closures_FileMeasureProgressCallback :: FileMeasureProgressCallback -> FileMeasureProgressCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FileMeasureProgressCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_FileMeasureProgressCallback
-> Bool	`reporting`: `True` if more reports will come
-> Word64	`currentSize`: the current cumulative size measurement
-> Word64	`numDirs`: the number of directories visited so far
-> Word64	`numFiles`: the number of non-directory files encountered
-> Ptr ()	`data`: the data passed to the original request for this callback
-> m ()

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

genClosure_FileMeasureProgressCallback :: MonadIO m => FileMeasureProgressCallback -> m (GClosure C_FileMeasureProgressCallback) Source #

Wrap the callback into a GClosure.

mk_FileMeasureProgressCallback :: C_FileMeasureProgressCallback -> IO (FunPtr C_FileMeasureProgressCallback) Source #

Generate a function pointer callable from C code, from a C_FileMeasureProgressCallback.

noFileMeasureProgressCallback :: Maybe FileMeasureProgressCallback Source #

A convenience synonym for Nothing :: Maybe FileMeasureProgressCallback.

noFileMeasureProgressCallback_WithClosures :: Maybe FileMeasureProgressCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe FileMeasureProgressCallback_WithClosures.

wrap_FileMeasureProgressCallback :: Maybe (Ptr (FunPtr C_FileMeasureProgressCallback)) -> FileMeasureProgressCallback_WithClosures -> C_FileMeasureProgressCallback Source #

Wrap a FileMeasureProgressCallback into a C_FileMeasureProgressCallback.

FileProgressCallback

type C_FileProgressCallback = Int64 -> Int64 -> Ptr () -> IO () Source #

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

type FileProgressCallback Source #

Arguments

= Int64	`currentNumBytes`: the current number of bytes in the operation.
-> Int64	`totalNumBytes`: the total number of bytes in the operation.
-> IO ()

When doing file operations that may take a while, such as moving a file or copying a file, a progress callback is used to pass how far along that operation is to the application.

type FileProgressCallback_WithClosures Source #

Arguments

= Int64	`currentNumBytes`: the current number of bytes in the operation.
-> Int64	`totalNumBytes`: the total number of bytes in the operation.
-> Ptr ()	`data`: user data passed to the callback.
-> IO ()

When doing file operations that may take a while, such as moving a file or copying a file, a progress callback is used to pass how far along that operation is to the application.

drop_closures_FileProgressCallback :: FileProgressCallback -> FileProgressCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FileProgressCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_FileProgressCallback
-> Int64	`currentNumBytes`: the current number of bytes in the operation.
-> Int64	`totalNumBytes`: the total number of bytes in the operation.
-> Ptr ()	`data`: user data passed to the callback.
-> m ()

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

genClosure_FileProgressCallback :: MonadIO m => FileProgressCallback -> m (GClosure C_FileProgressCallback) Source #

Wrap the callback into a GClosure.

mk_FileProgressCallback :: C_FileProgressCallback -> IO (FunPtr C_FileProgressCallback) Source #

Generate a function pointer callable from C code, from a C_FileProgressCallback.

noFileProgressCallback :: Maybe FileProgressCallback Source #

A convenience synonym for Nothing :: Maybe FileProgressCallback.

noFileProgressCallback_WithClosures :: Maybe FileProgressCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe FileProgressCallback_WithClosures.

wrap_FileProgressCallback :: Maybe (Ptr (FunPtr C_FileProgressCallback)) -> FileProgressCallback_WithClosures -> C_FileProgressCallback Source #

Wrap a FileProgressCallback into a C_FileProgressCallback.

FileReadMoreCallback

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

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

type FileReadMoreCallback Source #

Arguments

= Text	`fileContents`: the data as currently read.
-> Int64	`fileSize`: the size of the data currently read.
-> IO Bool	Returns: `True` if more data should be read back. `False` otherwise.

When loading the partial contents of a file with g_file_load_partial_contents_async(), it may become necessary to determine if any more data from the file should be loaded. A FileReadMoreCallback function facilitates this by returning True if more data should be read, or False otherwise.

type FileReadMoreCallback_WithClosures Source #

Arguments

= Text	`fileContents`: the data as currently read.
-> Int64	`fileSize`: the size of the data currently read.
-> Ptr ()	`callbackData`: data passed to the callback.
-> IO Bool	Returns: `True` if more data should be read back. `False` otherwise.

When loading the partial contents of a file with g_file_load_partial_contents_async(), it may become necessary to determine if any more data from the file should be loaded. A FileReadMoreCallback function facilitates this by returning True if more data should be read, or False otherwise.

drop_closures_FileReadMoreCallback :: FileReadMoreCallback -> FileReadMoreCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_FileReadMoreCallback Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_FileReadMoreCallback
-> Text	`fileContents`: the data as currently read.
-> Int64	`fileSize`: the size of the data currently read.
-> Ptr ()	`callbackData`: data passed to the callback.
-> m Bool	Returns: `True` if more data should be read back. `False` otherwise.

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

genClosure_FileReadMoreCallback :: MonadIO m => FileReadMoreCallback -> m (GClosure C_FileReadMoreCallback) Source #

Wrap the callback into a GClosure.

mk_FileReadMoreCallback :: C_FileReadMoreCallback -> IO (FunPtr C_FileReadMoreCallback) Source #

Generate a function pointer callable from C code, from a C_FileReadMoreCallback.

noFileReadMoreCallback :: Maybe FileReadMoreCallback Source #

A convenience synonym for Nothing :: Maybe FileReadMoreCallback.

noFileReadMoreCallback_WithClosures :: Maybe FileReadMoreCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe FileReadMoreCallback_WithClosures.

wrap_FileReadMoreCallback :: Maybe (Ptr (FunPtr C_FileReadMoreCallback)) -> FileReadMoreCallback_WithClosures -> C_FileReadMoreCallback Source #

Wrap a FileReadMoreCallback into a C_FileReadMoreCallback.

IOSchedulerJobFunc

type C_IOSchedulerJobFunc = Ptr IOSchedulerJob -> Ptr Cancellable -> Ptr () -> IO CInt Source #

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

type IOSchedulerJobFunc Source #

Arguments

= IOSchedulerJob	`job`: a `IOSchedulerJob`.
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> IO Bool	Returns: `True` if this function should be called again to complete the job, `False` if the job is complete (or cancelled)

Deprecated: (Since version 2.36)Use [structgLib.ThreadPool] or taskRunInThread

I/O Job function.

Long-running jobs should periodically check the cancellable to see if they have been cancelled.

type IOSchedulerJobFunc_WithClosures Source #

Arguments

= IOSchedulerJob	`job`: a `IOSchedulerJob`.
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> Ptr ()	`data`: data passed to the callback function
-> IO Bool	Returns: `True` if this function should be called again to complete the job, `False` if the job is complete (or cancelled)

I/O Job function.

Long-running jobs should periodically check the cancellable to see if they have been cancelled.

drop_closures_IOSchedulerJobFunc :: IOSchedulerJobFunc -> IOSchedulerJobFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_IOSchedulerJobFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsCancellable a)
=> FunPtr C_IOSchedulerJobFunc
-> IOSchedulerJob	`job`: a `IOSchedulerJob`.
-> Maybe a	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> Ptr ()	`data`: data passed to the callback function
-> m Bool	Returns: `True` if this function should be called again to complete the job, `False` if the job is complete (or cancelled)

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

genClosure_IOSchedulerJobFunc :: MonadIO m => IOSchedulerJobFunc -> m (GClosure C_IOSchedulerJobFunc) Source #

Wrap the callback into a GClosure.

mk_IOSchedulerJobFunc :: C_IOSchedulerJobFunc -> IO (FunPtr C_IOSchedulerJobFunc) Source #

Generate a function pointer callable from C code, from a C_IOSchedulerJobFunc.

noIOSchedulerJobFunc :: Maybe IOSchedulerJobFunc Source #

A convenience synonym for Nothing :: Maybe IOSchedulerJobFunc.

noIOSchedulerJobFunc_WithClosures :: Maybe IOSchedulerJobFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe IOSchedulerJobFunc_WithClosures.

wrap_IOSchedulerJobFunc :: Maybe (Ptr (FunPtr C_IOSchedulerJobFunc)) -> IOSchedulerJobFunc_WithClosures -> C_IOSchedulerJobFunc Source #

Wrap a IOSchedulerJobFunc into a C_IOSchedulerJobFunc.

InputStreamClassCloseAsyncFieldCallback

type C_InputStreamClassCloseAsyncFieldCallback = Ptr InputStream -> Int32 -> Ptr Cancellable -> FunPtr C_AsyncReadyCallback -> Ptr () -> IO () Source #

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

type InputStreamClassCloseAsyncFieldCallback Source #

Arguments

= InputStream	`stream`: A `InputStream`.
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request
-> Maybe Cancellable	`cancellable`: optional cancellable object
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> IO ()

No description available in the introspection data.

type InputStreamClassCloseAsyncFieldCallback_WithClosures Source #

Arguments

= InputStream	`stream`: A `InputStream`.
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request
-> Maybe Cancellable	`cancellable`: optional cancellable object
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> Ptr ()	`userData`: the data to pass to callback function
-> IO ()

No description available in the introspection data.

drop_closures_InputStreamClassCloseAsyncFieldCallback :: InputStreamClassCloseAsyncFieldCallback -> InputStreamClassCloseAsyncFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_InputStreamClassCloseAsyncFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b)
=> FunPtr C_InputStreamClassCloseAsyncFieldCallback
-> a	`stream`: A `InputStream`.
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request
-> Maybe b	`cancellable`: optional cancellable object
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> Ptr ()	`userData`: the data to pass to callback function
-> m ()

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

genClosure_InputStreamClassCloseAsyncFieldCallback :: MonadIO m => InputStreamClassCloseAsyncFieldCallback -> m (GClosure C_InputStreamClassCloseAsyncFieldCallback) Source #

Wrap the callback into a GClosure.

mk_InputStreamClassCloseAsyncFieldCallback :: C_InputStreamClassCloseAsyncFieldCallback -> IO (FunPtr C_InputStreamClassCloseAsyncFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassCloseAsyncFieldCallback.

noInputStreamClassCloseAsyncFieldCallback :: Maybe InputStreamClassCloseAsyncFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassCloseAsyncFieldCallback.

noInputStreamClassCloseAsyncFieldCallback_WithClosures :: Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures.

wrap_InputStreamClassCloseAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)) -> InputStreamClassCloseAsyncFieldCallback_WithClosures -> C_InputStreamClassCloseAsyncFieldCallback Source #

Wrap a InputStreamClassCloseAsyncFieldCallback into a C_InputStreamClassCloseAsyncFieldCallback.

InputStreamClassCloseFinishFieldCallback

type C_InputStreamClassCloseFinishFieldCallback = Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt Source #

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

type InputStreamClassCloseFinishFieldCallback Source #

Arguments

= InputStream	`stream`: a `InputStream`.
-> AsyncResult	`result`: a `AsyncResult`.
-> IO ()	Returns: `True` if the stream was closed successfully. (Can throw `GError`)

No description available in the introspection data.

dynamic_InputStreamClassCloseFinishFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b)
=> FunPtr C_InputStreamClassCloseFinishFieldCallback
-> a	`stream`: a `InputStream`.
-> b	`result`: a `AsyncResult`.
-> m ()	(Can throw `GError`)

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

mk_InputStreamClassCloseFinishFieldCallback :: C_InputStreamClassCloseFinishFieldCallback -> IO (FunPtr C_InputStreamClassCloseFinishFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassCloseFinishFieldCallback.

noInputStreamClassCloseFinishFieldCallback :: Maybe InputStreamClassCloseFinishFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassCloseFinishFieldCallback.

InputStreamClassCloseFnFieldCallback

type C_InputStreamClassCloseFnFieldCallback = Ptr InputStream -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt Source #

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

type InputStreamClassCloseFnFieldCallback Source #

Arguments

= InputStream
-> Maybe Cancellable
-> IO ()	(Can throw `GError`)

No description available in the introspection data.

dynamic_InputStreamClassCloseFnFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b)
=> FunPtr C_InputStreamClassCloseFnFieldCallback
-> a
-> Maybe b
-> m ()	(Can throw `GError`)

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

mk_InputStreamClassCloseFnFieldCallback :: C_InputStreamClassCloseFnFieldCallback -> IO (FunPtr C_InputStreamClassCloseFnFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassCloseFnFieldCallback.

noInputStreamClassCloseFnFieldCallback :: Maybe InputStreamClassCloseFnFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassCloseFnFieldCallback.

InputStreamClassReadAsyncFieldCallback

type C_InputStreamClassReadAsyncFieldCallback = Ptr InputStream -> Ptr Word8 -> CSize -> Int32 -> Ptr Cancellable -> FunPtr C_AsyncReadyCallback -> Ptr () -> IO () Source #

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

type InputStreamClassReadAsyncFieldCallback Source #

Arguments

= InputStream	`stream`: A `InputStream`.
-> Maybe ByteString	`buffer`: a buffer to read data into (which should be at least count bytes long).
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request.
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> IO (Maybe ByteString)

No description available in the introspection data.

type InputStreamClassReadAsyncFieldCallback_WithClosures Source #

Arguments

= InputStream	`stream`: A `InputStream`.
-> Maybe ByteString	`buffer`: a buffer to read data into (which should be at least count bytes long).
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request.
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> Ptr ()	`userData`: the data to pass to callback function
-> IO (Maybe ByteString)

No description available in the introspection data.

drop_closures_InputStreamClassReadAsyncFieldCallback :: InputStreamClassReadAsyncFieldCallback -> InputStreamClassReadAsyncFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_InputStreamClassReadAsyncFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b)
=> FunPtr C_InputStreamClassReadAsyncFieldCallback
-> a	`stream`: A `InputStream`.
-> Maybe ByteString	`buffer`: a buffer to read data into (which should be at least count bytes long).
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request.
-> Maybe b	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> Ptr ()	`userData`: the data to pass to callback function
-> m (Maybe ByteString)

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

genClosure_InputStreamClassReadAsyncFieldCallback :: MonadIO m => InputStreamClassReadAsyncFieldCallback -> m (GClosure C_InputStreamClassReadAsyncFieldCallback) Source #

Wrap the callback into a GClosure.

mk_InputStreamClassReadAsyncFieldCallback :: C_InputStreamClassReadAsyncFieldCallback -> IO (FunPtr C_InputStreamClassReadAsyncFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassReadAsyncFieldCallback.

noInputStreamClassReadAsyncFieldCallback :: Maybe InputStreamClassReadAsyncFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassReadAsyncFieldCallback.

noInputStreamClassReadAsyncFieldCallback_WithClosures :: Maybe InputStreamClassReadAsyncFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe InputStreamClassReadAsyncFieldCallback_WithClosures.

wrap_InputStreamClassReadAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)) -> InputStreamClassReadAsyncFieldCallback_WithClosures -> C_InputStreamClassReadAsyncFieldCallback Source #

Wrap a InputStreamClassReadAsyncFieldCallback into a C_InputStreamClassReadAsyncFieldCallback.

InputStreamClassReadFinishFieldCallback

type C_InputStreamClassReadFinishFieldCallback = Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO Int64 Source #

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

type InputStreamClassReadFinishFieldCallback Source #

Arguments

= InputStream	`stream`: a `InputStream`.
-> AsyncResult	`result`: a `AsyncResult`.
-> IO Int64	Returns: number of bytes read in, or -1 on error, or 0 on end of file. (Can throw `GError`)

No description available in the introspection data.

dynamic_InputStreamClassReadFinishFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b)
=> FunPtr C_InputStreamClassReadFinishFieldCallback
-> a	`stream`: a `InputStream`.
-> b	`result`: a `AsyncResult`.
-> m Int64	Returns: number of bytes read in, or -1 on error, or 0 on end of file. (Can throw `GError`)

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

mk_InputStreamClassReadFinishFieldCallback :: C_InputStreamClassReadFinishFieldCallback -> IO (FunPtr C_InputStreamClassReadFinishFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassReadFinishFieldCallback.

noInputStreamClassReadFinishFieldCallback :: Maybe InputStreamClassReadFinishFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassReadFinishFieldCallback.

InputStreamClassReadFnFieldCallback

type C_InputStreamClassReadFnFieldCallback = Ptr InputStream -> Ptr () -> CSize -> Ptr Cancellable -> Ptr (Ptr GError) -> IO Int64 Source #

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

type InputStreamClassReadFnFieldCallback Source #

Arguments

= InputStream
-> Ptr ()
-> CSize
-> Maybe Cancellable
-> IO Int64	(Can throw `GError`)

No description available in the introspection data.

dynamic_InputStreamClassReadFnFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b)
=> FunPtr C_InputStreamClassReadFnFieldCallback
-> a
-> Ptr ()
-> CSize
-> Maybe b
-> m Int64	(Can throw `GError`)

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

mk_InputStreamClassReadFnFieldCallback :: C_InputStreamClassReadFnFieldCallback -> IO (FunPtr C_InputStreamClassReadFnFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassReadFnFieldCallback.

noInputStreamClassReadFnFieldCallback :: Maybe InputStreamClassReadFnFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassReadFnFieldCallback.

InputStreamClassSkipAsyncFieldCallback

type C_InputStreamClassSkipAsyncFieldCallback = Ptr InputStream -> CSize -> Int32 -> Ptr Cancellable -> FunPtr C_AsyncReadyCallback -> Ptr () -> IO () Source #

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

type InputStreamClassSkipAsyncFieldCallback Source #

Arguments

= InputStream	`stream`: A `InputStream`.
-> CSize	`count`: the number of bytes that will be skipped from the stream
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> IO ()

No description available in the introspection data.

type InputStreamClassSkipAsyncFieldCallback_WithClosures Source #

Arguments

= InputStream	`stream`: A `InputStream`.
-> CSize	`count`: the number of bytes that will be skipped from the stream
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> Ptr ()	`userData`: the data to pass to callback function
-> IO ()

No description available in the introspection data.

drop_closures_InputStreamClassSkipAsyncFieldCallback :: InputStreamClassSkipAsyncFieldCallback -> InputStreamClassSkipAsyncFieldCallback_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_InputStreamClassSkipAsyncFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b)
=> FunPtr C_InputStreamClassSkipAsyncFieldCallback
-> a	`stream`: A `InputStream`.
-> CSize	`count`: the number of bytes that will be skipped from the stream
-> Int32	`ioPriority`: the [I/O priority][io-priority] of the request
-> Maybe b	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> Maybe AsyncReadyCallback_WithClosures	`callback`: a `AsyncReadyCallback` to call when the request is satisfied
-> Ptr ()	`userData`: the data to pass to callback function
-> m ()

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

genClosure_InputStreamClassSkipAsyncFieldCallback :: MonadIO m => InputStreamClassSkipAsyncFieldCallback -> m (GClosure C_InputStreamClassSkipAsyncFieldCallback) Source #

Wrap the callback into a GClosure.

mk_InputStreamClassSkipAsyncFieldCallback :: C_InputStreamClassSkipAsyncFieldCallback -> IO (FunPtr C_InputStreamClassSkipAsyncFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassSkipAsyncFieldCallback.

noInputStreamClassSkipAsyncFieldCallback :: Maybe InputStreamClassSkipAsyncFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassSkipAsyncFieldCallback.

noInputStreamClassSkipAsyncFieldCallback_WithClosures :: Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures Source #

A convenience synonym for Nothing :: Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures.

wrap_InputStreamClassSkipAsyncFieldCallback :: Maybe (Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)) -> InputStreamClassSkipAsyncFieldCallback_WithClosures -> C_InputStreamClassSkipAsyncFieldCallback Source #

Wrap a InputStreamClassSkipAsyncFieldCallback into a C_InputStreamClassSkipAsyncFieldCallback.

InputStreamClassSkipFieldCallback

type C_InputStreamClassSkipFieldCallback = Ptr InputStream -> CSize -> Ptr Cancellable -> Ptr (Ptr GError) -> IO Int64 Source #

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

type InputStreamClassSkipFieldCallback Source #

Arguments

= InputStream	`stream`: a `InputStream`.
-> CSize	`count`: the number of bytes that will be skipped from the stream
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> IO Int64	Returns: Number of bytes skipped, or -1 on error (Can throw `GError`)

No description available in the introspection data.

dynamic_InputStreamClassSkipFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b)
=> FunPtr C_InputStreamClassSkipFieldCallback
-> a	`stream`: a `InputStream`.
-> CSize	`count`: the number of bytes that will be skipped from the stream
-> Maybe b	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> m Int64	Returns: Number of bytes skipped, or -1 on error (Can throw `GError`)

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

mk_InputStreamClassSkipFieldCallback :: C_InputStreamClassSkipFieldCallback -> IO (FunPtr C_InputStreamClassSkipFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassSkipFieldCallback.

noInputStreamClassSkipFieldCallback :: Maybe InputStreamClassSkipFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassSkipFieldCallback.

InputStreamClassSkipFinishFieldCallback

type C_InputStreamClassSkipFinishFieldCallback = Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO Int64 Source #

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

type InputStreamClassSkipFinishFieldCallback Source #

Arguments

= InputStream	`stream`: a `InputStream`.
-> AsyncResult	`result`: a `AsyncResult`.
-> IO Int64	Returns: the size of the bytes skipped, or `-1` on error. (Can throw `GError`)

No description available in the introspection data.

dynamic_InputStreamClassSkipFinishFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b)
=> FunPtr C_InputStreamClassSkipFinishFieldCallback
-> a	`stream`: a `InputStream`.
-> b	`result`: a `AsyncResult`.
-> m Int64	Returns: the size of the bytes skipped, or `-1` on error. (Can throw `GError`)

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

mk_InputStreamClassSkipFinishFieldCallback :: C_InputStreamClassSkipFinishFieldCallback -> IO (FunPtr C_InputStreamClassSkipFinishFieldCallback) Source #

Generate a function pointer callable from C code, from a C_InputStreamClassSkipFinishFieldCallback.

noInputStreamClassSkipFinishFieldCallback :: Maybe InputStreamClassSkipFinishFieldCallback Source #

A convenience synonym for Nothing :: Maybe InputStreamClassSkipFinishFieldCallback.

PollableSourceFunc

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

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

type PollableSourceFunc Source #

Arguments

= Object	`pollableStream`: the `PollableInputStream` or `PollableOutputStream`
-> IO Bool	Returns: it should return `False` if the source should be removed.

This is the function type of the callback used for the Source returned by pollableInputStreamCreateSource and pollableOutputStreamCreateSource.

Since: 2.28

type PollableSourceFunc_WithClosures Source #

Arguments

= Object	`pollableStream`: the `PollableInputStream` or `PollableOutputStream`
-> Ptr ()	`data`: data passed in by the user.
-> IO Bool	Returns: it should return `False` if the source should be removed.

This is the function type of the callback used for the Source returned by pollableInputStreamCreateSource and pollableOutputStreamCreateSource.

Since: 2.28

drop_closures_PollableSourceFunc :: PollableSourceFunc -> PollableSourceFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_PollableSourceFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsObject a)
=> FunPtr C_PollableSourceFunc
-> a	`pollableStream`: the `PollableInputStream` or `PollableOutputStream`
-> Ptr ()	`data`: data passed in by the user.
-> m Bool	Returns: it should return `False` if the source should be removed.

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

genClosure_PollableSourceFunc :: MonadIO m => PollableSourceFunc -> m (GClosure C_PollableSourceFunc) Source #

Wrap the callback into a GClosure.

mk_PollableSourceFunc :: C_PollableSourceFunc -> IO (FunPtr C_PollableSourceFunc) Source #

Generate a function pointer callable from C code, from a C_PollableSourceFunc.

noPollableSourceFunc :: Maybe PollableSourceFunc Source #

A convenience synonym for Nothing :: Maybe PollableSourceFunc.

noPollableSourceFunc_WithClosures :: Maybe PollableSourceFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe PollableSourceFunc_WithClosures.

wrap_PollableSourceFunc :: Maybe (Ptr (FunPtr C_PollableSourceFunc)) -> PollableSourceFunc_WithClosures -> C_PollableSourceFunc Source #

Wrap a PollableSourceFunc into a C_PollableSourceFunc.

ReallocFunc

type C_ReallocFunc = Ptr () -> CSize -> IO (Ptr ()) Source #

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

type ReallocFunc Source #

Arguments

= Ptr ()	`data`: memory block to reallocate
-> CSize	`size`: size to reallocate `data` to
-> IO (Ptr ())	Returns: a pointer to the reallocated memory

Changes the size of the memory block pointed to by data to size bytes.

The function should have the same semantics as realloc().

dynamic_ReallocFunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_ReallocFunc
-> Ptr ()	`data`: memory block to reallocate
-> CSize	`size`: size to reallocate `data` to
-> m (Ptr ())	Returns: a pointer to the reallocated memory

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

genClosure_ReallocFunc :: MonadIO m => ReallocFunc -> m (GClosure C_ReallocFunc) Source #

Wrap the callback into a GClosure.

mk_ReallocFunc :: C_ReallocFunc -> IO (FunPtr C_ReallocFunc) Source #

Generate a function pointer callable from C code, from a C_ReallocFunc.

noReallocFunc :: Maybe ReallocFunc Source #

A convenience synonym for Nothing :: Maybe ReallocFunc.

wrap_ReallocFunc :: Maybe (Ptr (FunPtr C_ReallocFunc)) -> ReallocFunc -> C_ReallocFunc Source #

Wrap a ReallocFunc into a C_ReallocFunc.

SeekableIfaceCanSeekFieldCallback

type C_SeekableIfaceCanSeekFieldCallback = Ptr Seekable -> IO CInt Source #

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

type SeekableIfaceCanSeekFieldCallback Source #

Arguments

= Seekable	`seekable`: a `Seekable`.
-> IO Bool	Returns: `True` if `seekable` can be seeked. `False` otherwise.

No description available in the introspection data.

dynamic_SeekableIfaceCanSeekFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsSeekable a)
=> FunPtr C_SeekableIfaceCanSeekFieldCallback
-> a	`seekable`: a `Seekable`.
-> m Bool	Returns: `True` if `seekable` can be seeked. `False` otherwise.

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

genClosure_SeekableIfaceCanSeekFieldCallback :: MonadIO m => SeekableIfaceCanSeekFieldCallback -> m (GClosure C_SeekableIfaceCanSeekFieldCallback) Source #

Wrap the callback into a GClosure.

mk_SeekableIfaceCanSeekFieldCallback :: C_SeekableIfaceCanSeekFieldCallback -> IO (FunPtr C_SeekableIfaceCanSeekFieldCallback) Source #

Generate a function pointer callable from C code, from a C_SeekableIfaceCanSeekFieldCallback.

noSeekableIfaceCanSeekFieldCallback :: Maybe SeekableIfaceCanSeekFieldCallback Source #

A convenience synonym for Nothing :: Maybe SeekableIfaceCanSeekFieldCallback.

wrap_SeekableIfaceCanSeekFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)) -> SeekableIfaceCanSeekFieldCallback -> C_SeekableIfaceCanSeekFieldCallback Source #

Wrap a SeekableIfaceCanSeekFieldCallback into a C_SeekableIfaceCanSeekFieldCallback.

SeekableIfaceCanTruncateFieldCallback

type C_SeekableIfaceCanTruncateFieldCallback = Ptr Seekable -> IO CInt Source #

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

type SeekableIfaceCanTruncateFieldCallback Source #

Arguments

= Seekable	`seekable`: a `Seekable`.
-> IO Bool	Returns: `True` if the stream can be truncated, `False` otherwise.

No description available in the introspection data.

dynamic_SeekableIfaceCanTruncateFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsSeekable a)
=> FunPtr C_SeekableIfaceCanTruncateFieldCallback
-> a	`seekable`: a `Seekable`.
-> m Bool	Returns: `True` if the stream can be truncated, `False` otherwise.

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

genClosure_SeekableIfaceCanTruncateFieldCallback :: MonadIO m => SeekableIfaceCanTruncateFieldCallback -> m (GClosure C_SeekableIfaceCanTruncateFieldCallback) Source #

Wrap the callback into a GClosure.

mk_SeekableIfaceCanTruncateFieldCallback :: C_SeekableIfaceCanTruncateFieldCallback -> IO (FunPtr C_SeekableIfaceCanTruncateFieldCallback) Source #

Generate a function pointer callable from C code, from a C_SeekableIfaceCanTruncateFieldCallback.

noSeekableIfaceCanTruncateFieldCallback :: Maybe SeekableIfaceCanTruncateFieldCallback Source #

A convenience synonym for Nothing :: Maybe SeekableIfaceCanTruncateFieldCallback.

wrap_SeekableIfaceCanTruncateFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceCanTruncateFieldCallback)) -> SeekableIfaceCanTruncateFieldCallback -> C_SeekableIfaceCanTruncateFieldCallback Source #

Wrap a SeekableIfaceCanTruncateFieldCallback into a C_SeekableIfaceCanTruncateFieldCallback.

SeekableIfaceSeekFieldCallback

type C_SeekableIfaceSeekFieldCallback = Ptr Seekable -> Int64 -> CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt Source #

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

type SeekableIfaceSeekFieldCallback Source #

Arguments

= Seekable	`seekable`: a `Seekable`.
-> Int64	`offset`: a `goffset`.
-> SeekType	`type`: a `SeekType`.
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> IO ()	Returns: `True` if successful. If an error has occurred, this function will return `False` and set `error` appropriately if present. (Can throw `GError`)

No description available in the introspection data.

dynamic_SeekableIfaceSeekFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsSeekable a, IsCancellable b)
=> FunPtr C_SeekableIfaceSeekFieldCallback
-> a	`seekable`: a `Seekable`.
-> Int64	`offset`: a `goffset`.
-> SeekType	`type`: a `SeekType`.
-> Maybe b	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> m ()	(Can throw `GError`)

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

mk_SeekableIfaceSeekFieldCallback :: C_SeekableIfaceSeekFieldCallback -> IO (FunPtr C_SeekableIfaceSeekFieldCallback) Source #

Generate a function pointer callable from C code, from a C_SeekableIfaceSeekFieldCallback.

noSeekableIfaceSeekFieldCallback :: Maybe SeekableIfaceSeekFieldCallback Source #

A convenience synonym for Nothing :: Maybe SeekableIfaceSeekFieldCallback.

SeekableIfaceTellFieldCallback

type C_SeekableIfaceTellFieldCallback = Ptr Seekable -> IO Int64 Source #

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

type SeekableIfaceTellFieldCallback Source #

Arguments

= Seekable	`seekable`: a `Seekable`.
-> IO Int64	Returns: the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.

No description available in the introspection data.

dynamic_SeekableIfaceTellFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsSeekable a)
=> FunPtr C_SeekableIfaceTellFieldCallback
-> a	`seekable`: a `Seekable`.
-> m Int64	Returns: the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.

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

genClosure_SeekableIfaceTellFieldCallback :: MonadIO m => SeekableIfaceTellFieldCallback -> m (GClosure C_SeekableIfaceTellFieldCallback) Source #

Wrap the callback into a GClosure.

mk_SeekableIfaceTellFieldCallback :: C_SeekableIfaceTellFieldCallback -> IO (FunPtr C_SeekableIfaceTellFieldCallback) Source #

Generate a function pointer callable from C code, from a C_SeekableIfaceTellFieldCallback.

noSeekableIfaceTellFieldCallback :: Maybe SeekableIfaceTellFieldCallback Source #

A convenience synonym for Nothing :: Maybe SeekableIfaceTellFieldCallback.

wrap_SeekableIfaceTellFieldCallback :: Maybe (Ptr (FunPtr C_SeekableIfaceTellFieldCallback)) -> SeekableIfaceTellFieldCallback -> C_SeekableIfaceTellFieldCallback Source #

Wrap a SeekableIfaceTellFieldCallback into a C_SeekableIfaceTellFieldCallback.

SeekableIfaceTruncateFnFieldCallback

type C_SeekableIfaceTruncateFnFieldCallback = Ptr Seekable -> Int64 -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt Source #

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

type SeekableIfaceTruncateFnFieldCallback Source #

Arguments

= Seekable	`seekable`: a `Seekable`.
-> Int64	`offset`: new length for `seekable`, in bytes.
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> IO ()	Returns: `True` if successful. If an error has occurred, this function will return `False` and set `error` appropriately if present. (Can throw `GError`)

No description available in the introspection data.

dynamic_SeekableIfaceTruncateFnFieldCallback Source #

Arguments

:: (HasCallStack, MonadIO m, IsSeekable a, IsCancellable b)
=> FunPtr C_SeekableIfaceTruncateFnFieldCallback
-> a	`seekable`: a `Seekable`.
-> Int64	`offset`: new length for `seekable`, in bytes.
-> Maybe b	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> m ()	(Can throw `GError`)

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

mk_SeekableIfaceTruncateFnFieldCallback :: C_SeekableIfaceTruncateFnFieldCallback -> IO (FunPtr C_SeekableIfaceTruncateFnFieldCallback) Source #

Generate a function pointer callable from C code, from a C_SeekableIfaceTruncateFnFieldCallback.

noSeekableIfaceTruncateFnFieldCallback :: Maybe SeekableIfaceTruncateFnFieldCallback Source #

A convenience synonym for Nothing :: Maybe SeekableIfaceTruncateFnFieldCallback.

SettingsBindGetMapping

type C_SettingsBindGetMapping = Ptr GValue -> Ptr GVariant -> Ptr () -> IO CInt Source #

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

type SettingsBindGetMapping Source #

Arguments

= GValue	`value`: return location for the property value
-> GVariant	`variant`: the `GVariant`
-> IO Bool	Returns: `True` if the conversion succeeded, `False` in case of an error

The type for the function that is used to convert from Settings to an object property. The value is already initialized to hold values of the appropriate type.

type SettingsBindGetMapping_WithClosures Source #

Arguments

= GValue	`value`: return location for the property value
-> GVariant	`variant`: the `GVariant`
-> Ptr ()	`userData`: user data that was specified when the binding was created
-> IO Bool	Returns: `True` if the conversion succeeded, `False` in case of an error

The type for the function that is used to convert from Settings to an object property. The value is already initialized to hold values of the appropriate type.

drop_closures_SettingsBindGetMapping :: SettingsBindGetMapping -> SettingsBindGetMapping_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SettingsBindGetMapping Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_SettingsBindGetMapping
-> GValue	`value`: return location for the property value
-> GVariant	`variant`: the `GVariant`
-> Ptr ()	`userData`: user data that was specified when the binding was created
-> m Bool	Returns: `True` if the conversion succeeded, `False` in case of an error

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

genClosure_SettingsBindGetMapping :: MonadIO m => SettingsBindGetMapping -> m (GClosure C_SettingsBindGetMapping) Source #

Wrap the callback into a GClosure.

mk_SettingsBindGetMapping :: C_SettingsBindGetMapping -> IO (FunPtr C_SettingsBindGetMapping) Source #

Generate a function pointer callable from C code, from a C_SettingsBindGetMapping.

noSettingsBindGetMapping :: Maybe SettingsBindGetMapping Source #

A convenience synonym for Nothing :: Maybe SettingsBindGetMapping.

noSettingsBindGetMapping_WithClosures :: Maybe SettingsBindGetMapping_WithClosures Source #

A convenience synonym for Nothing :: Maybe SettingsBindGetMapping_WithClosures.

wrap_SettingsBindGetMapping :: Maybe (Ptr (FunPtr C_SettingsBindGetMapping)) -> SettingsBindGetMapping_WithClosures -> C_SettingsBindGetMapping Source #

Wrap a SettingsBindGetMapping into a C_SettingsBindGetMapping.

SettingsBindSetMapping

type C_SettingsBindSetMapping = Ptr GValue -> Ptr VariantType -> Ptr () -> IO (Ptr GVariant) Source #

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

type SettingsBindSetMapping Source #

Arguments

= GValue	`value`: a `Value` containing the property value to map
-> VariantType	`expectedType`: the `VariantType` to create
-> IO GVariant	Returns: a new `GVariant` holding the data from `value`, or `Nothing` in case of an error

The type for the function that is used to convert an object property value to a GVariant for storing it in Settings.

type SettingsBindSetMapping_WithClosures Source #

Arguments

= GValue	`value`: a `Value` containing the property value to map
-> VariantType	`expectedType`: the `VariantType` to create
-> Ptr ()	`userData`: user data that was specified when the binding was created
-> IO GVariant	Returns: a new `GVariant` holding the data from `value`, or `Nothing` in case of an error

The type for the function that is used to convert an object property value to a GVariant for storing it in Settings.

drop_closures_SettingsBindSetMapping :: SettingsBindSetMapping -> SettingsBindSetMapping_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SettingsBindSetMapping Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_SettingsBindSetMapping
-> GValue	`value`: a `Value` containing the property value to map
-> VariantType	`expectedType`: the `VariantType` to create
-> Ptr ()	`userData`: user data that was specified when the binding was created
-> m GVariant	Returns: a new `GVariant` holding the data from `value`, or `Nothing` in case of an error

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

genClosure_SettingsBindSetMapping :: MonadIO m => SettingsBindSetMapping -> m (GClosure C_SettingsBindSetMapping) Source #

Wrap the callback into a GClosure.

mk_SettingsBindSetMapping :: C_SettingsBindSetMapping -> IO (FunPtr C_SettingsBindSetMapping) Source #

Generate a function pointer callable from C code, from a C_SettingsBindSetMapping.

noSettingsBindSetMapping :: Maybe SettingsBindSetMapping Source #

A convenience synonym for Nothing :: Maybe SettingsBindSetMapping.

noSettingsBindSetMapping_WithClosures :: Maybe SettingsBindSetMapping_WithClosures Source #

A convenience synonym for Nothing :: Maybe SettingsBindSetMapping_WithClosures.

wrap_SettingsBindSetMapping :: Maybe (Ptr (FunPtr C_SettingsBindSetMapping)) -> SettingsBindSetMapping_WithClosures -> C_SettingsBindSetMapping Source #

Wrap a SettingsBindSetMapping into a C_SettingsBindSetMapping.

SettingsGetMapping

type C_SettingsGetMapping = Ptr GVariant -> Ptr (Ptr ()) -> Ptr () -> IO CInt Source #

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

type SettingsGetMapping Source #

Arguments

= GVariant	`value`: the `GVariant` to map, or `Nothing`
-> IO (Bool, Ptr ())	Returns: `True` if the conversion succeeded, `False` in case of an error

The type of the function that is used to convert from a value stored in a Settings to a value that is useful to the application.

If the value is successfully mapped, the result should be stored at result and True returned. If mapping fails (for example, if value is not in the right format) then False should be returned.

If value is Nothing then it means that the mapping function is being given a "last chance" to successfully return a valid value. True must be returned in this case.

type SettingsGetMapping_WithClosures Source #

Arguments

= GVariant	`value`: the `GVariant` to map, or `Nothing`
-> Ptr ()	`userData`: the user data that was passed to `settingsGetMapped`
-> IO (Bool, Ptr ())	Returns: `True` if the conversion succeeded, `False` in case of an error

The type of the function that is used to convert from a value stored in a Settings to a value that is useful to the application.

If the value is successfully mapped, the result should be stored at result and True returned. If mapping fails (for example, if value is not in the right format) then False should be returned.

If value is Nothing then it means that the mapping function is being given a "last chance" to successfully return a valid value. True must be returned in this case.

drop_closures_SettingsGetMapping :: SettingsGetMapping -> SettingsGetMapping_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SettingsGetMapping Source #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_SettingsGetMapping
-> GVariant	`value`: the `GVariant` to map, or `Nothing`
-> Ptr ()	`userData`: the user data that was passed to `settingsGetMapped`
-> m (Bool, Ptr ())	Returns: `True` if the conversion succeeded, `False` in case of an error

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

genClosure_SettingsGetMapping :: MonadIO m => SettingsGetMapping -> m (GClosure C_SettingsGetMapping) Source #

Wrap the callback into a GClosure.

mk_SettingsGetMapping :: C_SettingsGetMapping -> IO (FunPtr C_SettingsGetMapping) Source #

Generate a function pointer callable from C code, from a C_SettingsGetMapping.

noSettingsGetMapping :: Maybe SettingsGetMapping Source #

A convenience synonym for Nothing :: Maybe SettingsGetMapping.

noSettingsGetMapping_WithClosures :: Maybe SettingsGetMapping_WithClosures Source #

A convenience synonym for Nothing :: Maybe SettingsGetMapping_WithClosures.

wrap_SettingsGetMapping :: Maybe (Ptr (FunPtr C_SettingsGetMapping)) -> SettingsGetMapping_WithClosures -> C_SettingsGetMapping Source #

Wrap a SettingsGetMapping into a C_SettingsGetMapping.

SimpleAsyncThreadFunc

type C_SimpleAsyncThreadFunc = Ptr SimpleAsyncResult -> Ptr Object -> Ptr Cancellable -> IO () Source #

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

type SimpleAsyncThreadFunc Source #

Arguments

= SimpleAsyncResult	`res`: a `SimpleAsyncResult`.
-> Object	`object`: a `Object`.
-> Maybe Cancellable	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> IO ()

Simple thread function that runs an asynchronous operation and checks for cancellation.

dynamic_SimpleAsyncThreadFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsSimpleAsyncResult a, IsObject b, IsCancellable c)
=> FunPtr C_SimpleAsyncThreadFunc
-> a	`res`: a `SimpleAsyncResult`.
-> b	`object`: a `Object`.
-> Maybe c	`cancellable`: optional `Cancellable` object, `Nothing` to ignore.
-> m ()

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

genClosure_SimpleAsyncThreadFunc :: MonadIO m => SimpleAsyncThreadFunc -> m (GClosure C_SimpleAsyncThreadFunc) Source #

Wrap the callback into a GClosure.

mk_SimpleAsyncThreadFunc :: C_SimpleAsyncThreadFunc -> IO (FunPtr C_SimpleAsyncThreadFunc) Source #

Generate a function pointer callable from C code, from a C_SimpleAsyncThreadFunc.

noSimpleAsyncThreadFunc :: Maybe SimpleAsyncThreadFunc Source #

A convenience synonym for Nothing :: Maybe SimpleAsyncThreadFunc.

wrap_SimpleAsyncThreadFunc :: Maybe (Ptr (FunPtr C_SimpleAsyncThreadFunc)) -> SimpleAsyncThreadFunc -> C_SimpleAsyncThreadFunc Source #

Wrap a SimpleAsyncThreadFunc into a C_SimpleAsyncThreadFunc.

SocketSourceFunc

type C_SocketSourceFunc = Ptr Socket -> CUInt -> Ptr () -> IO CInt Source #

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

type SocketSourceFunc Source #

Arguments

= Socket	`socket`: the `Socket`
-> [IOCondition]	`condition`: the current condition at the source fired.
-> IO Bool	Returns: it should return `False` if the source should be removed.

This is the function type of the callback used for the Source returned by g_socket_create_source().

Since: 2.22

type SocketSourceFunc_WithClosures Source #

Arguments

= Socket	`socket`: the `Socket`
-> [IOCondition]	`condition`: the current condition at the source fired.
-> Ptr ()	`data`: data passed in by the user.
-> IO Bool	Returns: it should return `False` if the source should be removed.

This is the function type of the callback used for the Source returned by g_socket_create_source().

Since: 2.22

drop_closures_SocketSourceFunc :: SocketSourceFunc -> SocketSourceFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_SocketSourceFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsSocket a)
=> FunPtr C_SocketSourceFunc
-> a	`socket`: the `Socket`
-> [IOCondition]	`condition`: the current condition at the source fired.
-> Ptr ()	`data`: data passed in by the user.
-> m Bool	Returns: it should return `False` if the source should be removed.

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

genClosure_SocketSourceFunc :: MonadIO m => SocketSourceFunc -> m (GClosure C_SocketSourceFunc) Source #

Wrap the callback into a GClosure.

mk_SocketSourceFunc :: C_SocketSourceFunc -> IO (FunPtr C_SocketSourceFunc) Source #

Generate a function pointer callable from C code, from a C_SocketSourceFunc.

noSocketSourceFunc :: Maybe SocketSourceFunc Source #

A convenience synonym for Nothing :: Maybe SocketSourceFunc.

noSocketSourceFunc_WithClosures :: Maybe SocketSourceFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe SocketSourceFunc_WithClosures.

wrap_SocketSourceFunc :: Maybe (Ptr (FunPtr C_SocketSourceFunc)) -> SocketSourceFunc_WithClosures -> C_SocketSourceFunc Source #

Wrap a SocketSourceFunc into a C_SocketSourceFunc.

TaskThreadFunc

type C_TaskThreadFunc = Ptr Task -> Ptr Object -> Ptr () -> Ptr Cancellable -> IO () Source #

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

type TaskThreadFunc Source #

Arguments

= Task	`task`: the `Task`
-> Object	`sourceObject`: `task`'s source object
-> Ptr ()	`taskData`: `task`'s task data
-> Maybe Cancellable	`cancellable`: `task`'s `Cancellable`, or `Nothing`
-> IO ()

The prototype for a task function to be run in a thread via taskRunInThread or taskRunInThreadSync.

If the return-on-cancel flag is set on task, and cancellable gets cancelled, then the Task will be completed immediately (as though taskReturnErrorIfCancelled had been called), without waiting for the task function to complete. However, the task function will continue running in its thread in the background. The function therefore needs to be careful about how it uses externally-visible state in this case. See taskSetReturnOnCancel for more details.

Other than in that case, task will be completed when the TaskThreadFunc returns, not when it calls a g_task_return_ function.

Since: 2.36

dynamic_TaskThreadFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsTask a, IsObject b, IsCancellable c)
=> FunPtr C_TaskThreadFunc
-> a	`task`: the `Task`
-> b	`sourceObject`: `task`'s source object
-> Ptr ()	`taskData`: `task`'s task data
-> Maybe c	`cancellable`: `task`'s `Cancellable`, or `Nothing`
-> m ()

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

genClosure_TaskThreadFunc :: MonadIO m => TaskThreadFunc -> m (GClosure C_TaskThreadFunc) Source #

Wrap the callback into a GClosure.

mk_TaskThreadFunc :: C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc) Source #

Generate a function pointer callable from C code, from a C_TaskThreadFunc.

noTaskThreadFunc :: Maybe TaskThreadFunc Source #

A convenience synonym for Nothing :: Maybe TaskThreadFunc.

wrap_TaskThreadFunc :: Maybe (Ptr (FunPtr C_TaskThreadFunc)) -> TaskThreadFunc -> C_TaskThreadFunc Source #

Wrap a TaskThreadFunc into a C_TaskThreadFunc.

VfsFileLookupFunc

type C_VfsFileLookupFunc = Ptr Vfs -> CString -> Ptr () -> IO (Ptr File) Source #

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

type VfsFileLookupFunc Source #

Arguments

= Vfs	`vfs`: a `Vfs`
-> Text	`identifier`: the identifier to look up a `File` for. This can either be an URI or a parse name as returned by `fileGetParseName`
-> IO File	Returns: a `File` for `identifier`.

This function type is used by vfsRegisterUriScheme to make it possible for a client to associate an URI scheme to a different File implementation.

The client should return a reference to the new file that has been created for uri, or Nothing to continue with the default implementation.

Since: 2.50

type VfsFileLookupFunc_WithClosures Source #

Arguments

= Vfs	`vfs`: a `Vfs`
-> Text	`identifier`: the identifier to look up a `File` for. This can either be an URI or a parse name as returned by `fileGetParseName`
-> Ptr ()	`userData`: user data passed to the function
-> IO File	Returns: a `File` for `identifier`.

This function type is used by vfsRegisterUriScheme to make it possible for a client to associate an URI scheme to a different File implementation.

The client should return a reference to the new file that has been created for uri, or Nothing to continue with the default implementation.

Since: 2.50

drop_closures_VfsFileLookupFunc :: VfsFileLookupFunc -> VfsFileLookupFunc_WithClosures Source #

A simple wrapper that ignores the closure arguments.

dynamic_VfsFileLookupFunc Source #

Arguments

:: (HasCallStack, MonadIO m, IsVfs a)
=> FunPtr C_VfsFileLookupFunc
-> a	`vfs`: a `Vfs`
-> Text	`identifier`: the identifier to look up a `File` for. This can either be an URI or a parse name as returned by `fileGetParseName`
-> Ptr ()	`userData`: user data passed to the function
-> m File	Returns: a `File` for `identifier`.

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

genClosure_VfsFileLookupFunc :: MonadIO m => VfsFileLookupFunc -> m (GClosure C_VfsFileLookupFunc) Source #

Wrap the callback into a GClosure.

mk_VfsFileLookupFunc :: C_VfsFileLookupFunc -> IO (FunPtr C_VfsFileLookupFunc) Source #

Generate a function pointer callable from C code, from a C_VfsFileLookupFunc.

noVfsFileLookupFunc :: Maybe VfsFileLookupFunc Source #

A convenience synonym for Nothing :: Maybe VfsFileLookupFunc.

noVfsFileLookupFunc_WithClosures :: Maybe VfsFileLookupFunc_WithClosures Source #

A convenience synonym for Nothing :: Maybe VfsFileLookupFunc_WithClosures.

wrap_VfsFileLookupFunc :: Maybe (Ptr (FunPtr C_VfsFileLookupFunc)) -> VfsFileLookupFunc_WithClosures -> C_VfsFileLookupFunc Source #

Wrap a VfsFileLookupFunc into a C_VfsFileLookupFunc.