gi-gio-2.0.32: Gio bindings

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

GI.Gio.Callbacks

Contents

- Signals
  - ActionEntryActivateFieldCallback
  - ActionEntryChangeStateFieldCallback
  - AsyncReadyCallback
  - BusAcquiredCallback
  - BusNameAcquiredCallback
  - BusNameAppearedCallback
  - BusNameLostCallback
  - BusNameVanishedCallback
  - CancellableSourceFunc
  - DBusInterfaceGetPropertyFunc
  - DBusInterfaceMethodCallFunc
  - DBusInterfaceSetPropertyFunc
  - DBusMessageFilterFunction
  - DBusProxyTypeFunc
  - DBusSignalCallback
  - DBusSubtreeDispatchFunc
  - DBusSubtreeEnumerateFunc
  - DBusSubtreeIntrospectFunc
  - DatagramBasedSourceFunc
  - DesktopAppLaunchCallback
  - FileMeasureProgressCallback
  - FileProgressCallback
  - FileReadMoreCallback
  - IOSchedulerJobFunc
  - PollableSourceFunc
  - ReallocFunc
  - SettingsBindGetMapping
  - SettingsBindSetMapping
  - SettingsGetMapping
  - SimpleAsyncThreadFunc
  - SocketSourceFunc
  - TaskThreadFunc
  - VfsFileLookupFunc

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_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 () -> Word64 -> IO (Ptr ())
- type ReallocFunc = Ptr () -> Word64 -> IO (Ptr ())
- dynamic_ReallocFunc :: (HasCallStack, MonadIO m) => FunPtr C_ReallocFunc -> Ptr () -> Word64 -> 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_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); > > // modify` copy > > 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); > > // modify` copy > > 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 [struct`gLib`.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`.

## 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 () -> Word64 -> IO (Ptr ()) Source #

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

type ReallocFunc Source #

Arguments

= Ptr () | `data`: memory block to reallocate
-> Word64 | `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
-> Word64 | `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`.

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